static int __init kudp_init(void) { netlink_sock = netlink_kernel_create(&init_net, NETLINK_USERSOCK, 0,udp_receive, NULL, THIS_MODULE); return 0; }
/** * \fn wlanDrvIf_Create * \brief Create the driver instance * * Allocate driver object. * Initialize driver OS resources (IRQ, workqueue, events socket) * Setup driver network interface. * Create and link all driver modules. * * \note * \param void * \return 0 - OK, else - failure * \sa wlanDrvIf_Destroy */ static int wlanDrvIf_Create (void) { TWlanDrvIfObj *drv; int rc; /* Allocate driver's structure */ drv = kmalloc (sizeof(TWlanDrvIfObj), GFP_KERNEL); if (!drv) { return -ENOMEM; } #ifdef TI_DBG tb_init(TB_OPTION_NONE); #endif pDrvStaticHandle = drv; /* save for module destroy */ #ifdef TI_MEM_ALLOC_TRACE os_printf ("MTT:%s:%d ::kmalloc(%lu, %x) : %lu\n", __FUNCTION__, __LINE__, sizeof(TWlanDrvIfObj), GFP_KERNEL, sizeof(TWlanDrvIfObj)); #endif memset (drv, 0, sizeof(TWlanDrvIfObj)); drv->bSuspendInProgress = TI_FALSE; drv->tCommon.eDriverState = DRV_STATE_IDLE; #ifdef AP_MODE_ENABLED /* for STA role, need to allocate another driver and to set STA role */ drv->tCommon.eIfRole = IF_ROLE_TYPE_AP; #endif drv->pWorkQueue = create_freezeable_workqueue(TIWLAN_WQ_NAME); if (!drv->pWorkQueue) { ti_dprintf (TIWLAN_LOG_ERROR, "wlanDrvIf_Create(): Failed to create workQ!\n"); rc = -EINVAL; goto drv_create_end_1; } drv->wl_packet = 0; drv->wl_count = 0; #ifdef CONFIG_HAS_WAKELOCK wake_lock_init (&drv->wl_wifi, WAKE_LOCK_SUSPEND, "wifi_wake"); wake_lock_init (&drv->wl_rxwake, WAKE_LOCK_SUSPEND, "wifi_rx_wake"); #endif #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23) INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask, (void *)drv); #else INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask); #endif spin_lock_init (&drv->lock); /* Setup driver network interface. */ rc = wlanDrvIf_SetupNetif (drv); if (rc) { goto drv_create_end_2; } /* Create the events socket interface */ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23) drv->wl_sock = netlink_kernel_create( NETLINK_USERSOCK, 0, NULL, THIS_MODULE ); #else drv->wl_sock = netlink_kernel_create(&init_net, NETLINK_USERSOCK, 0, NULL, NULL, THIS_MODULE ); #endif if (drv->wl_sock == NULL) { ti_dprintf (TIWLAN_LOG_ERROR, "netlink_kernel_create() failed !\n"); rc = -EINVAL; goto drv_create_end_3; } /* Create all driver modules and link their handles */ rc = drvMain_Create (drv, &drv->tCommon.hDrvMain, &drv->tCommon.hCmdHndlr, &drv->tCommon.hContext, &drv->tCommon.hTxDataQ, &drv->tCommon.hTxMgmtQ, &drv->tCommon.hTxCtrl, &drv->tCommon.hTWD, &drv->tCommon.hEvHandler, &drv->tCommon.hCmdDispatch, &drv->tCommon.hReport); if (rc != TI_OK) { ti_dprintf (TIWLAN_LOG_ERROR, "%s: Failed to dvrMain_Create!\n", __func__); rc = -EINVAL; goto drv_create_end_4; } /* * Initialize interrupts (or polling mode for debug): */ #ifdef PRIODIC_INTERRUPT /* Debug mode: Polling (the timer is started by HwInit process) */ drv->hPollTimer = os_timerCreate ((TI_HANDLE)drv, wlanDrvIf_PollIrqHandler, (TI_HANDLE)drv); #else /* Normal mode: Interrupts (the default mode) */ rc = hPlatform_initInterrupt (drv, (void*)wlanDrvIf_HandleInterrupt); if (rc) { ti_dprintf (TIWLAN_LOG_ERROR, "wlanDrvIf_Create(): Failed to register interrupt handler!\n"); goto drv_create_end_5; } #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23) set_irq_type (drv->irq, IRQT_FALLING); #endif #endif /* PRIODIC_INTERRUPT */ return 0; drv_create_end_5: if (drv->tCommon.hDrvMain) { drvMain_Destroy (drv->tCommon.hDrvMain); } drv_create_end_4: if (drv->wl_sock) { sock_release (drv->wl_sock->sk_socket); } drv_create_end_3: if (drv->netdev) { unregister_netdev (drv->netdev); free_netdev (drv->netdev); } drv_create_end_2: #ifdef CONFIG_HAS_WAKELOCK wake_lock_destroy (&drv->wl_wifi); wake_lock_destroy (&drv->wl_rxwake); #endif if (drv->pWorkQueue) { destroy_workqueue (drv->pWorkQueue); } drv_create_end_1: kfree (drv); printk ("%s: Fail, rc = %d\n", __func__, rc); return rc; }
void create_permission_socket(void) { per_sock = netlink_kernel_create(&init_net, NETLINK_PERMISSON_TYPE, 0, msg_receive, NULL, THIS_MODULE); if (!per_sock) { printk(KERN_ERR "can not create a netlink socket."); } }
/** * \fn wlanDrvIf_Create * \brief Create the driver instance * * Allocate driver object. * Initialize driver OS resources (IRQ, workqueue, events socket) * Setup driver network interface. * Create and link all driver modules. * * \note * \param void * \return 0 - OK, else - failure * \sa wlanDrvIf_Destroy */ static int wlanDrvIf_Create (void) { TWlanDrvIfObj *drv; int rc; /* Allocate driver's structure */ drv = kmalloc (sizeof(TWlanDrvIfObj), GFP_KERNEL); if (!drv) { return -ENOMEM; } #ifdef TI_DBG tb_init(TB_OPTION_NONE); #endif pDrvStaticHandle = drv; /* save for module destroy */ #ifdef TI_MEM_ALLOC_TRACE os_printf ("MTT:%s:%d ::kmalloc(%lu, %x) : %lu\n", __FUNCTION__, __LINE__, sizeof(TWlanDrvIfObj), GFP_KERNEL, sizeof(TWlanDrvIfObj)); #endif memset (drv, 0, sizeof(TWlanDrvIfObj)); drv->tCommon.eDriverState = DRV_STATE_IDLE; drv->pWorkQueue = create_singlethread_workqueue(TIWLAN_WQ_NAME); if (!drv->pWorkQueue) { return -ENOMEM; } drv->wl_packet = 0; drv->wl_count = 0; #ifdef CONFIG_HAS_WAKELOCK wake_lock_init(&drv->wl_wifi, WAKE_LOCK_SUSPEND, "wifi_wake"); wake_lock_init(&drv->wl_rxwake, WAKE_LOCK_SUSPEND, "wifi_rx_wake"); #endif #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23) INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask, (void *)drv); #else INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask); #endif spin_lock_init (&drv->lock); /* Setup driver network interface. */ rc = wlanDrvIf_SetupNetif (drv); if (rc) { kfree (drv); return rc; } /* Create the events socket interface */ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23) drv->wl_sock = netlink_kernel_create( NETLINK_USERSOCK, 0, NULL, THIS_MODULE ); #else drv->wl_sock = netlink_kernel_create(&init_net, NETLINK_USERSOCK, 0, NULL, NULL, THIS_MODULE ); #endif if (drv->wl_sock == NULL) { ti_dprintf (TIWLAN_LOG_ERROR, "netlink_kernel_create() failed !\n"); return -EINVAL; } /* Create all driver modules and link their handles */ drvMain_Create (drv, &drv->tCommon.hDrvMain, &drv->tCommon.hCmdHndlr, &drv->tCommon.hContext, &drv->tCommon.hTxDataQ, &drv->tCommon.hTxMgmtQ, &drv->tCommon.hTxCtrl, &drv->tCommon.hTWD, &drv->tCommon.hEvHandler, &drv->tCommon.hCmdDispatch, &drv->tCommon.hReport); /* * Initialize interrupts (or polling mode for debug): */ #ifdef PRIODIC_INTERRUPT /* Debug mode: Polling (the timer is started by HwInit process) */ drv->hPollTimer = os_timerCreate ((TI_HANDLE)drv, wlanDrvIf_PollIrqHandler, (TI_HANDLE)drv); #else /* Normal mode: Interrupts (the default mode) */ rc = hPlatform_initInterrupt (drv, (void*)wlanDrvIf_HandleInterrupt); if (rc) { ti_dprintf (TIWLAN_LOG_ERROR, "wlanDrvIf_Create(): Failed to register interrupt handler!\n"); return rc; } #endif /* PRIODIC_INTERRUPT */ #ifdef CONFIG_PM /* register PM hooks in our SDIO driver */ sdioDrv_register_pm(wlanDrvIf_Resume, wlanDrvIf_Suspend); #endif return 0; }
static struct sock *_rmnet_config_start_netlink(void) { return netlink_kernel_create(&init_net, RMNET_NETLINK_PROTO, &rmnet_netlink_cfg); }
int shrm_protocol_init(struct shrm_dev *shrm, received_msg_handler common_rx_handler, received_msg_handler audio_rx_handler) { int err; shm_dev = shrm; boot_state = BOOT_INIT; dev_info(shrm->dev, "IPC_ISA BOOT_INIT\n"); rx_common_handler = common_rx_handler; rx_audio_handler = audio_rx_handler; atomic_set(&ac_sleep_disable_count, 0); is_earlydrop = cpu_is_u8500ed(); if (is_earlydrop != 0x01) { hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); timer.function = callback; } hrtimer_init(&mod_stuck_timer_0, CLOCK_MONOTONIC, HRTIMER_MODE_REL); mod_stuck_timer_0.function = shm_mod_stuck_timeout; hrtimer_init(&mod_stuck_timer_1, CLOCK_MONOTONIC, HRTIMER_MODE_REL); mod_stuck_timer_1.function = shm_mod_stuck_timeout; hrtimer_init(&fifo_full_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); fifo_full_timer.function = shm_fifo_full_timeout; shrm->shm_common_ch_wr_wq = create_singlethread_workqueue ("shm_common_channel_irq"); if (!shrm->shm_common_ch_wr_wq) { dev_err(shrm->dev, "failed to create work queue\n"); return -ENOMEM; } shrm->shm_audio_ch_wr_wq = create_rt_workqueue ("shm_audio_channel_irq"); if (!shrm->shm_audio_ch_wr_wq) { dev_err(shrm->dev, "failed to create work queue\n"); err = -ENOMEM; goto free_wq1; } shrm->shm_ac_wake_wq = create_rt_workqueue("shm_ac_wake_req"); if (!shrm->shm_ac_wake_wq) { dev_err(shrm->dev, "failed to create work queue\n"); err = -ENOMEM; goto free_wq2; } shrm->shm_ca_wake_wq = create_rt_workqueue("shm_ca_wake_req"); if (!shrm->shm_ca_wake_wq) { dev_err(shrm->dev, "failed to create work queue\n"); err = -ENOMEM; goto free_wq3; } shrm->shm_ac_sleep_wq = create_singlethread_workqueue ("shm_ac_sleep_req"); if (!shrm->shm_ac_sleep_wq) { dev_err(shrm->dev, "failed to create work queue\n"); err = -ENOMEM; goto free_wq4; } shrm->shm_mod_stuck_wq = create_rt_workqueue("shm_mod_reset_req"); if (!shrm->shm_mod_stuck_wq) { dev_err(shrm->dev, "failed to create work queue\n"); err = -ENOMEM; goto free_wq5; } INIT_WORK(&shrm->send_ac_msg_pend_notify_0, send_ac_msg_pend_notify_0_work); INIT_WORK(&shrm->send_ac_msg_pend_notify_1, send_ac_msg_pend_notify_1_work); INIT_WORK(&shrm->shm_ca_wake_req, shm_ca_wake_req_work); INIT_WORK(&shrm->shm_ca_sleep_req, shm_ca_sleep_req_work); INIT_WORK(&shrm->shm_ac_sleep_req, shm_ac_sleep_req_work); INIT_WORK(&shrm->shm_ac_wake_req, shm_ac_wake_req_work); INIT_WORK(&shrm->shm_mod_reset_req, shm_mod_reset_work); /* set tasklet data */ shm_ca_0_tasklet.data = (unsigned long)shrm; shm_ca_1_tasklet.data = (unsigned long)shrm; err = request_irq(IRQ_PRCMU_CA_SLEEP, shrm_prcmu_irq_handler, IRQF_NO_SUSPEND, "ca-sleep", shrm); if (err < 0) { dev_err(shm_dev->dev, "Failed alloc IRQ_PRCMU_CA_SLEEP.\n"); goto free_wq6; } err = request_irq(IRQ_PRCMU_CA_WAKE, shrm_prcmu_irq_handler, IRQF_NO_SUSPEND, "ca-wake", shrm); if (err < 0) { dev_err(shm_dev->dev, "Failed alloc IRQ_PRCMU_CA_WAKE.\n"); goto drop2; } err = request_irq(IRQ_PRCMU_MODEM_SW_RESET_REQ, shrm_prcmu_irq_handler, IRQF_NO_SUSPEND, "modem-sw-reset-req", shrm); if (err < 0) { dev_err(shm_dev->dev, "Failed alloc IRQ_PRCMU_MODEM_SW_RESET_REQ.\n"); goto drop1; } #ifdef CONFIG_U8500_SHRM_MODEM_SILENT_RESET /* init netlink socket for user-space communication */ shrm_nl_sk = netlink_kernel_create(NULL, NETLINK_SHRM, 1, shm_nl_receive, NULL, THIS_MODULE); if (!shrm_nl_sk) { dev_err(shm_dev->dev, "netlink socket creation failed\n"); goto drop; } #endif return 0; #ifdef CONFIG_U8500_SHRM_MODEM_SILENT_RESET drop: free_irq(IRQ_PRCMU_MODEM_SW_RESET_REQ, NULL); #endif drop1: free_irq(IRQ_PRCMU_CA_WAKE, NULL); drop2: free_irq(IRQ_PRCMU_CA_SLEEP, NULL); free_wq6: destroy_workqueue(shrm->shm_mod_stuck_wq); free_wq5: destroy_workqueue(shrm->shm_ac_sleep_wq); free_wq4: destroy_workqueue(shrm->shm_ca_wake_wq); free_wq3: destroy_workqueue(shrm->shm_ac_wake_wq); free_wq2: destroy_workqueue(shrm->shm_audio_ch_wr_wq); free_wq1: destroy_workqueue(shrm->shm_common_ch_wr_wq); return err; }
static void ipt_logfn(unsigned int hooknum, const struct sk_buff *skb, const struct net_device *in, const struct net_device *out, const char *prefix) { struct ipt_ulog_info loginfo = { .nl_group = ULOG_DEFAULT_NLGROUP, .copy_range = 0, .qthreshold = ULOG_DEFAULT_QTHRESHOLD, .prefix = "" }; ipt_ulog_packet(hooknum, skb, in, out, &loginfo, prefix); } static int ipt_ulog_checkentry(const char *tablename, const struct ipt_entry *e, void *targinfo, unsigned int targinfosize, unsigned int hookmask) { struct ipt_ulog_info *loginfo = (struct ipt_ulog_info *) targinfo; if (targinfosize != IPT_ALIGN(sizeof(struct ipt_ulog_info))) { DEBUGP("ipt_ULOG: targinfosize %u != 0\n", targinfosize); return 0; } if (loginfo->prefix[sizeof(loginfo->prefix) - 1] != '\0') { DEBUGP("ipt_ULOG: prefix term %i\n", loginfo->prefix[sizeof(loginfo->prefix) - 1]); return 0; } if (loginfo->qthreshold > ULOG_MAX_QLEN) { DEBUGP("ipt_ULOG: queue threshold %i > MAX_QLEN\n", loginfo->qthreshold); return 0; } return 1; } static struct ipt_target ipt_ulog_reg = { .name = "ULOG", .target = ipt_ulog_target, .checkentry = ipt_ulog_checkentry, .me = THIS_MODULE, }; static int __init init(void) { int i; DEBUGP("ipt_ULOG: init module\n"); if (nlbufsiz >= 128*1024) { printk("Netlink buffer has to be <= 128kB\n"); return -EINVAL; } /* initialize ulog_buffers */ for (i = 0; i < ULOG_MAXNLGROUPS; i++) { init_timer(&ulog_buffers[i].timer); ulog_buffers[i].timer.function = ulog_timer; ulog_buffers[i].timer.data = i; } nflognl = netlink_kernel_create(NETLINK_NFLOG, NULL); if (!nflognl) return -ENOMEM; if (ipt_register_target(&ipt_ulog_reg) != 0) { sock_release(nflognl->sk_socket); return -EINVAL; } if (nflog) nf_log_register(PF_INET, &ipt_logfn); return 0; } static void __exit fini(void) { ulog_buff_t *ub; int i; DEBUGP("ipt_ULOG: cleanup_module\n"); if (nflog) nf_log_unregister(PF_INET, &ipt_logfn); ipt_unregister_target(&ipt_ulog_reg); sock_release(nflognl->sk_socket); /* remove pending timers and free allocated skb's */ for (i = 0; i < ULOG_MAXNLGROUPS; i++) { ub = &ulog_buffers[i]; if (timer_pending(&ub->timer)) { DEBUGP("timer was pending, deleting\n"); del_timer(&ub->timer); } if (ub->skb) { kfree_skb(ub->skb); ub->skb = NULL; } } }
int sdio_netlink_register(void) { netlink_sock = netlink_kernel_create(&init_net, NETLINK_USERSOCK, 0, udp_receive, NULL, THIS_MODULE); return 0; }