本文整理汇总了C++中create_singlethread_workqueue函数的典型用法代码示例。如果您正苦于以下问题:C++ create_singlethread_workqueue函数的具体用法?C++ create_singlethread_workqueue怎么用?C++ create_singlethread_workqueue使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了create_singlethread_workqueue函数的20个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于我们的系统推荐出更棒的C++代码示例。
示例1: bridge_init
static int __init bridge_init(void)
{
struct data_bridge *dev;
int ret;
int i = 0;
ret = ctrl_bridge_init();
if (ret)
return ret;
bridge_wq = create_singlethread_workqueue("mdm_bridge");
if (!bridge_wq) {
pr_err("%s: Unable to create workqueue:bridge\n", __func__);
ret = -ENOMEM;
goto free_ctrl;
}
for (i = 0; i < MAX_BRIDGE_DEVICES; i++) {
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev) {
err("%s: unable to allocate dev\n", __func__);
ret = -ENOMEM;
goto error;
}
dev->wq = bridge_wq;
init_usb_anchor(&dev->tx_active);
init_usb_anchor(&dev->rx_active);
INIT_LIST_HEAD(&dev->rx_idle);
skb_queue_head_init(&dev->rx_done);
INIT_WORK(&dev->kevent, defer_kevent);
INIT_WORK(&dev->process_rx_w, data_bridge_process_rx);
__dev[i] = dev;
}
ret = usb_register(&bridge_driver);
if (ret) {
err("%s: unable to register mdm_bridge driver", __func__);
goto error;
}
data_bridge_debugfs_init();
return 0;
error:
while (--i >= 0) {
kfree(__dev[i]);
__dev[i] = NULL;
}
destroy_workqueue(bridge_wq);
free_ctrl:
ctrl_bridge_exit();
return ret;
}
开发者ID:downthemachine,项目名称:arthur_msm-JB-3.4-vanilla,代码行数:61,代码来源:mdm_data_bridge.c
示例2: ieee80211_register_hw
//.........这里部分代码省略.........
if (!local->ops->hw_scan) {
/* For hw_scan, driver needs to set these up. */
local->hw.wiphy->max_scan_ssids = 4;
local->hw.wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
}
/*
* If the driver supports any scan IEs, then assume the
* limit includes the IEs mac80211 will add, otherwise
* leave it at zero and let the driver sort it out; we
* still pass our IEs to the driver but userspace will
* not be allowed to in that case.
*/
if (local->hw.wiphy->max_scan_ie_len)
local->hw.wiphy->max_scan_ie_len -= local->scan_ies_len;
local->hw.wiphy->cipher_suites = cipher_suites;
local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
if (!(local->hw.flags & IEEE80211_HW_MFP_CAPABLE))
local->hw.wiphy->n_cipher_suites--;
result = wiphy_register(local->hw.wiphy);
if (result < 0)
goto fail_wiphy_register;
/*
* We use the number of queues for feature tests (QoS, HT) internally
* so restrict them appropriately.
*/
if (hw->queues > IEEE80211_MAX_QUEUES)
hw->queues = IEEE80211_MAX_QUEUES;
local->workqueue =
create_singlethread_workqueue(wiphy_name(local->hw.wiphy));
if (!local->workqueue) {
result = -ENOMEM;
goto fail_workqueue;
}
/*
* The hardware needs headroom for sending the frame,
* and we need some headroom for passing the frame to monitor
* interfaces, but never both at the same time.
*/
BUILD_BUG_ON(IEEE80211_TX_STATUS_HEADROOM !=
sizeof(struct ieee80211_tx_status_rtap_hdr));
local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom,
sizeof(struct ieee80211_tx_status_rtap_hdr));
debugfs_hw_add(local);
if (local->hw.max_listen_interval == 0)
local->hw.max_listen_interval = 1;
local->hw.conf.listen_interval = local->hw.max_listen_interval;
result = sta_info_start(local);
if (result < 0)
goto fail_sta_info;
result = ieee80211_wep_init(local);
if (result < 0) {
printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n",
wiphy_name(local->hw.wiphy), result);
goto fail_wep;
}
开发者ID:AdrianHuang,项目名称:uclinux-robutest,代码行数:67,代码来源:main.c
示例3: ieee80211_alloc_hw
static struct ieee80211_hw *cw1200_init_common(const u8 *macaddr,
const bool have_5ghz)
{
int i, band;
struct ieee80211_hw *hw;
struct cw1200_common *priv;
hw = ieee80211_alloc_hw(sizeof(struct cw1200_common), &cw1200_ops);
if (!hw)
return NULL;
priv = hw->priv;
priv->hw = hw;
priv->hw_type = -1;
priv->mode = NL80211_IFTYPE_UNSPECIFIED;
priv->rates = cw1200_rates; /* TODO: fetch from FW */
priv->mcs_rates = cw1200_n_rates;
if (cw1200_ba_rx_tids != -1)
priv->ba_rx_tid_mask = cw1200_ba_rx_tids;
else
priv->ba_rx_tid_mask = 0xFF; /* Enable RX BLKACK for all TIDs */
if (cw1200_ba_tx_tids != -1)
priv->ba_tx_tid_mask = cw1200_ba_tx_tids;
else
priv->ba_tx_tid_mask = 0xff; /* Enable TX BLKACK for all TIDs */
ieee80211_hw_set(hw, NEED_DTIM_BEFORE_ASSOC);
ieee80211_hw_set(hw, TX_AMPDU_SETUP_IN_HW);
ieee80211_hw_set(hw, AMPDU_AGGREGATION);
ieee80211_hw_set(hw, CONNECTION_MONITOR);
ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
ieee80211_hw_set(hw, SIGNAL_DBM);
ieee80211_hw_set(hw, SUPPORTS_PS);
hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
BIT(NL80211_IFTYPE_ADHOC) |
BIT(NL80211_IFTYPE_AP) |
BIT(NL80211_IFTYPE_MESH_POINT) |
BIT(NL80211_IFTYPE_P2P_CLIENT) |
BIT(NL80211_IFTYPE_P2P_GO);
#ifdef CONFIG_PM
hw->wiphy->wowlan = &cw1200_wowlan_support;
#endif
hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
hw->queues = 4;
priv->rts_threshold = -1;
hw->max_rates = 8;
hw->max_rate_tries = 15;
hw->extra_tx_headroom = WSM_TX_EXTRA_HEADROOM +
8; /* TKIP IV */
hw->sta_data_size = sizeof(struct cw1200_sta_priv);
hw->wiphy->bands[NL80211_BAND_2GHZ] = &cw1200_band_2ghz;
if (have_5ghz)
hw->wiphy->bands[NL80211_BAND_5GHZ] = &cw1200_band_5ghz;
/* Channel params have to be cleared before registering wiphy again */
for (band = 0; band < NUM_NL80211_BANDS; band++) {
struct ieee80211_supported_band *sband = hw->wiphy->bands[band];
if (!sband)
continue;
for (i = 0; i < sband->n_channels; i++) {
sband->channels[i].flags = 0;
sband->channels[i].max_antenna_gain = 0;
sband->channels[i].max_power = 30;
}
}
hw->wiphy->max_scan_ssids = 2;
hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
if (macaddr)
SET_IEEE80211_PERM_ADDR(hw, (u8 *)macaddr);
else
SET_IEEE80211_PERM_ADDR(hw, cw1200_mac_template);
/* Fix up mac address if necessary */
if (hw->wiphy->perm_addr[3] == 0 &&
hw->wiphy->perm_addr[4] == 0 &&
hw->wiphy->perm_addr[5] == 0) {
get_random_bytes(&hw->wiphy->perm_addr[3], 3);
}
mutex_init(&priv->wsm_cmd_mux);
mutex_init(&priv->conf_mutex);
priv->workqueue = create_singlethread_workqueue("cw1200_wq");
sema_init(&priv->scan.lock, 1);
INIT_WORK(&priv->scan.work, cw1200_scan_work);
INIT_DELAYED_WORK(&priv->scan.probe_work, cw1200_probe_work);
INIT_DELAYED_WORK(&priv->scan.timeout, cw1200_scan_timeout);
INIT_DELAYED_WORK(&priv->clear_recent_scan_work,
cw1200_clear_recent_scan_work);
INIT_DELAYED_WORK(&priv->join_timeout, cw1200_join_timeout);
//.........这里部分代码省略.........
开发者ID:ReneNyffenegger,项目名称:linux,代码行数:101,代码来源:main.c
示例4: cw_bat_probe
static int cw_bat_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct cw_battery *cw_bat;
int ret;
int irq;
int irq_flags;
int loop = 0;
cw_bat = devm_kzalloc(&client->dev, sizeof(*cw_bat), GFP_KERNEL);
if (!cw_bat) {
dev_err(&cw_bat->client->dev, "fail to allocate memory\n");
return -ENOMEM;
}
i2c_set_clientdata(client, cw_bat);
cw_bat->plat_data = client->dev.platform_data;
ret = cw_bat_gpio_init(cw_bat);
if (ret) {
dev_err(&cw_bat->client->dev, "cw_bat_gpio_init error\n");
return ret;
}
cw_bat->client = client;
ret = cw_init(cw_bat);
while ((loop++ < 200) && (ret != 0)) {
ret = cw_init(cw_bat);
}
if (ret)
return ret;
cw_bat->rk_bat.name = "rk-bat";
cw_bat->rk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
cw_bat->rk_bat.properties = rk_battery_properties;
cw_bat->rk_bat.num_properties = ARRAY_SIZE(rk_battery_properties);
cw_bat->rk_bat.get_property = rk_battery_get_property;
ret = power_supply_register(&client->dev, &cw_bat->rk_bat);
if(ret < 0) {
dev_err(&cw_bat->client->dev, "power supply register rk_bat error\n");
goto rk_bat_register_fail;
}
cw_bat->rk_ac.name = "rk-ac";
cw_bat->rk_ac.type = POWER_SUPPLY_TYPE_MAINS;
cw_bat->rk_ac.properties = rk_ac_properties;
cw_bat->rk_ac.num_properties = ARRAY_SIZE(rk_ac_properties);
cw_bat->rk_ac.get_property = rk_ac_get_property;
ret = power_supply_register(&client->dev, &cw_bat->rk_ac);
if(ret < 0) {
dev_err(&cw_bat->client->dev, "power supply register rk_ac error\n");
goto rk_ac_register_fail;
}
cw_bat->rk_usb.name = "rk-usb";
cw_bat->rk_usb.type = POWER_SUPPLY_TYPE_USB;
cw_bat->rk_usb.properties = rk_usb_properties;
cw_bat->rk_usb.num_properties = ARRAY_SIZE(rk_usb_properties);
cw_bat->rk_usb.get_property = rk_usb_get_property;
ret = power_supply_register(&client->dev, &cw_bat->rk_usb);
if(ret < 0) {
dev_err(&cw_bat->client->dev, "power supply register rk_ac error\n");
goto rk_usb_register_fail;
}
cw_bat->charger_init_mode = dwc_otg_check_dpdm();
cw_bat->dc_online = 0;
cw_bat->usb_online = 0;
cw_bat->charger_mode = 0;
cw_bat->capacity = 2;
cw_bat->voltage = 0;
cw_bat->status = 0;
cw_bat->time_to_empty = 0;
cw_bat->bat_change = 0;
cw_update_time_member_capacity_change(cw_bat);
cw_update_time_member_charge_start(cw_bat);
cw_bat->battery_workqueue = create_singlethread_workqueue("rk_battery");
INIT_DELAYED_WORK(&cw_bat->battery_delay_work, cw_bat_work);
INIT_DELAYED_WORK(&cw_bat->dc_wakeup_work, dc_detect_do_wakeup);
queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(10));
if (cw_bat->plat_data->dc_det_pin != INVALID_GPIO) {
irq = gpio_to_irq(cw_bat->plat_data->dc_det_pin);
irq_flags = gpio_get_value(cw_bat->plat_data->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
ret = request_irq(irq, dc_detect_irq_handler, irq_flags, "usb_detect", cw_bat);
if (ret < 0) {
pr_err("%s: request_irq(%d) failed\n", __func__, irq);
}
enable_irq_wake(irq);
}
#ifdef BAT_LOW_INTERRUPT
INIT_DELAYED_WORK(&cw_bat->bat_low_wakeup_work, bat_low_detect_do_wakeup);
wake_lock_init(&bat_low_wakelock, WAKE_LOCK_SUSPEND, "bat_low_detect");
if (cw_bat->plat_data->bat_low_pin != INVALID_GPIO) {
irq = gpio_to_irq(cw_bat->plat_data->bat_low_pin);
ret = request_irq(irq, bat_low_detect_irq_handler, IRQF_TRIGGER_RISING, "bat_low_detect", cw_bat);
//.........这里部分代码省略.........
开发者ID:Dee-UK,项目名称:RK3188_KK_4.4.02_Beta,代码行数:101,代码来源:cw2015_battery.c
示例5: bma020_acc_start
int bma020_acc_start(void)
{
int result,err;
struct input_dev *input_dev;
struct device *dev_t;
bma020acc_t accels;
result = register_chrdev( ACC_DEV_MAJOR, ACC_DEV_NAME, &acc_fops);
if (result < 0)
{
return result;
}
acc_class = class_create (THIS_MODULE, ACC_DEV_NAME);
if (IS_ERR(acc_class))
{
unregister_chrdev( ACC_DEV_MAJOR, ACC_DEV_NAME);
return PTR_ERR( acc_class );
}
dev_t = device_create( acc_class, NULL, MKDEV(ACC_DEV_MAJOR, 0), "%s", ACC_DEV_NAME);
if (IS_ERR(dev_t))
{
return PTR_ERR(dev_t);
}
/*For testing*/
if (device_create_file(dev_t, &dev_attr_acc_file) < 0)
printk("Failed to create device file %s \n", dev_attr_acc_file.attr.name);
mutex_init(&bma020.power_lock);
/* hrtimer settings. we poll for light values using a timer. */
hrtimer_init(&bma020.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
bma020.acc_poll_delay = ns_to_ktime(240 * NSEC_PER_MSEC);
bma020.timer.function = bma_timer_func;
/* the timer just fires off a work queue request. we need a thread
to read the i2c (can be slow and blocking). */
bma020.wq = create_singlethread_workqueue("bma_wq");
if (!bma020.wq) {
err = -ENOMEM;
printk("%s: could not create workqueue\n", __func__);
goto err_create_workqueue;
}
/* this is the thread function we run on the work queue */
INIT_WORK(&bma020.work_acc, bma_work_func_acc);
/* allocate lightsensor-level input_device */
input_dev = input_allocate_device();
if (!input_dev) {
printk("%s: could not allocate input device\n", __func__);
err = -ENOMEM;
goto err_input_allocate_device_light;
}
input_set_drvdata(input_dev, &bma020);
input_dev->name = "accel";
set_bit(EV_ABS, input_dev->evbit);
/* acceleration x-axis */
input_set_capability(input_dev, EV_ABS, ABS_X);
input_set_abs_params(input_dev, ABS_X, -1024, 1024, 0, 0);
/* acceleration y-axis */
input_set_capability(input_dev, EV_ABS, ABS_Y);
input_set_abs_params(input_dev, ABS_Y, -1024, 1024, 0, 0);
/* acceleration z-axis */
input_set_capability(input_dev, EV_ABS, ABS_Z);
input_set_abs_params(input_dev, ABS_Z, -1024, 1024, 0, 0);
printk("registering lightsensor-level input device\n");
err = input_register_device(input_dev);
if (err < 0) {
printk("%s: could not register input device\n", __func__);
input_free_device(input_dev);
goto err_input_register_device_light;
}
bma020.acc_input_dev = input_dev;
err = sysfs_create_group(&input_dev->dev.kobj,&acc_attribute_group);
if (err) {
printk("Creating bma020 attribute group failed");
goto error_device;
}
//////////////////////////////////////////////////////////////////////////////
result = i2c_acc_bma020_init();
if(result)
{
return result;
}
bma020_chip_init();
//.........这里部分代码省略.........
开发者ID:Arakmar,项目名称:G3MOD,代码行数:101,代码来源:bma020_acc.c
示例6: pixcir_probe
static int pixcir_probe(struct platform_device *pdev)
{
int i;
int err = 0;
struct pixcir_data *pixcir = platform_get_drvdata(pdev);
INIT_DELAYED_WORK(&pixcir->read_work, pixcir_read_work);
pixcir->workqueue = create_singlethread_workqueue(pixcir->name);
if (!pixcir->workqueue) {
err = -ESRCH;
goto exit_create_singlethread;
}
err = pixcir_sysfs_create_group(pixcir, &pixcir_group);
if(err < 0){
dbg("create sysfs group failed.\n");
goto exit_create_group;
}
pixcir->input_dev = input_allocate_device();
if (!pixcir->input_dev) {
err = -ENOMEM;
dbg("failed to allocate input device\n");
goto exit_input_dev_alloc_failed;
}
pixcir->input_dev->name = pixcir->name;
pixcir->input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
set_bit(INPUT_PROP_DIRECT, pixcir->input_dev->propbit);
input_set_abs_params(pixcir->input_dev,
ABS_MT_POSITION_X, 0, pixcir->xresl, 0, 0);
input_set_abs_params(pixcir->input_dev,
ABS_MT_POSITION_Y, 0, pixcir->yresl, 0, 0);
input_set_abs_params(pixcir->input_dev,
ABS_MT_TRACKING_ID, 0, 20, 0, 0);
#ifdef TOUCH_KEY
for (i = 0; i <NUM_KEYS; i++)
set_bit(keycodes[i], pixcir->input_dev->keybit);
pixcir->input_dev->keycode = keycodes;
pixcir->input_dev->keycodesize = sizeof(unsigned int);
pixcir->input_dev->keycodemax = NUM_KEYS;
#endif
pixcir->earlysus = 1;
err = input_register_device(pixcir->input_dev);
if (err) {
dbg_err("pixcir_ts_probe: failed to register input device.\n");
goto exit_input_register_device_failed;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
pixcir->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
pixcir->early_suspend.suspend = pixcir_early_suspend;
pixcir->early_suspend.resume = pixcir_late_resume;
register_early_suspend(&pixcir->early_suspend);
#endif
if(request_irq(pixcir->irq, pixcir_isr_handler, IRQF_SHARED, pixcir->name, pixcir) < 0){
dbg_err("Could not allocate irq for ts_pixcir !\n");
err = -1;
goto exit_register_irq;
}
gpio_enable(pixcir->igp_idx, pixcir->igp_bit, INPUT);
gpio_pull_enable(pixcir->igp_idx, pixcir->igp_bit, PULL_UP);
gpio_setup_irq(pixcir->igp_idx, pixcir->igp_bit, IRQ_FALLING);
pixcir_reset(pixcir);
msleep(200);
pixcir_active(pixcir);
pixcir->earlysus = 0;
return 0;
exit_register_irq:
unregister_early_suspend(&pixcir->early_suspend);
exit_input_register_device_failed:
input_free_device(pixcir->input_dev);
exit_input_dev_alloc_failed:
pixcir_sysfs_remove_group(pixcir, &pixcir_group);
exit_create_group:
cancel_delayed_work_sync(&pixcir->read_work);
destroy_workqueue(pixcir->workqueue);
exit_create_singlethread:
//kfree(pixcir);
return err;
}
开发者ID:Rumorbox33,项目名称:wm8850,代码行数:88,代码来源:pixcir_tangoc.c
示例7: diagfwd_sdio_init
void diagfwd_sdio_init(const char *name)
{
int ret;
if (diag9k_debug_mask)
DIAG_INFO("%s\n", __func__);
driver->read_len_mdm = 0;
if (driver->buf_in_sdio_1 == NULL)
driver->buf_in_sdio_1 = kzalloc(MAX_IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_sdio_1 == NULL)
goto err;
if (driver->buf_in_sdio_2 == NULL)
driver->buf_in_sdio_2 = kzalloc(MAX_IN_BUF_SIZE, GFP_KERNEL);
if (driver->buf_in_sdio_2 == NULL)
goto err;
if (driver->usb_buf_mdm_out == NULL)
driver->usb_buf_mdm_out = kzalloc(USB_MAX_OUT_BUF, GFP_KERNEL);
if (driver->usb_buf_mdm_out == NULL)
goto err;
if (driver->write_ptr_mdm_1 == NULL)
driver->write_ptr_mdm_1 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_mdm_1 == NULL)
goto err;
if (driver->write_ptr_mdm_2 == NULL)
driver->write_ptr_mdm_2 = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_mdm_2 == NULL)
goto err;
if (driver->usb_read_mdm_ptr == NULL)
driver->usb_read_mdm_ptr = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->usb_read_mdm_ptr == NULL)
goto err;
driver->diag_sdio_wq = create_singlethread_workqueue("diag_sdio_wq");
#ifdef CONFIG_DIAG_OVER_USB
strncpy(usb_ch_name, name, 16);
DIAG_INFO("%s using %s\n", __func__, usb_ch_name);
/*
driver->mdm_ch = usb_diag_open(DIAG_MDM, driver,
diag_usb_legacy_notifier);
if (IS_ERR(driver->mdm_ch)) {
printk(KERN_ERR "Unable to open USB diag MDM channel\n");
goto err;
}
*/
INIT_WORK(&(driver->diag_read_mdm_work), diag_read_mdm_work_fn);
#endif
INIT_WORK(&(driver->diag_read_sdio_work), diag_read_sdio_work_fn);
INIT_WORK(&(driver->diag_remove_sdio_work), diag_remove_sdio_work_fn);
ret = platform_driver_register(&msm_sdio_ch_driver);
if (ret)
DIAG_INFO("DIAG could not register SDIO device");
else
DIAG_INFO("DIAG registered SDIO device\n");
ril_sdio_dbg_flag = (get_kernel_flag() & BIT19)?1 :0;
return;
err:
DIAG_INFO("\n Could not initialize diag buf for SDIO");
kfree(driver->buf_in_sdio_1);
kfree(driver->buf_in_sdio_2);
kfree(driver->usb_buf_mdm_out);
kfree(driver->write_ptr_mdm_1);
kfree(driver->write_ptr_mdm_2);
kfree(driver->usb_read_mdm_ptr);
if (driver->diag_sdio_wq)
destroy_workqueue(driver->diag_sdio_wq);
}
开发者ID:AmeriCanAndroid,项目名称:kernel-android-msm-2.6.35,代码行数:71,代码来源:diagfwd_sdio.c
示例8: qxl_device_init
//.........这里部分代码省略.........
(int)qdev->surfaceram_size / 1024,
(sb == 4) ? "64bit" : "32bit");
qdev->rom = ioremap(qdev->rom_base, qdev->rom_size);
if (!qdev->rom) {
pr_err("Unable to ioremap ROM\n");
return -ENOMEM;
}
qxl_check_device(qdev);
r = qxl_bo_init(qdev);
if (r) {
DRM_ERROR("bo init failed %d\n", r);
return r;
}
qdev->ram_header = ioremap(qdev->vram_base +
qdev->rom->ram_header_offset,
sizeof(*qdev->ram_header));
qdev->command_ring = qxl_ring_create(&(qdev->ram_header->cmd_ring_hdr),
sizeof(struct qxl_command),
QXL_COMMAND_RING_SIZE,
qdev->io_base + QXL_IO_NOTIFY_CMD,
false,
&qdev->display_event);
qdev->cursor_ring = qxl_ring_create(
&(qdev->ram_header->cursor_ring_hdr),
sizeof(struct qxl_command),
QXL_CURSOR_RING_SIZE,
qdev->io_base + QXL_IO_NOTIFY_CMD,
false,
&qdev->cursor_event);
qdev->release_ring = qxl_ring_create(
&(qdev->ram_header->release_ring_hdr),
sizeof(uint64_t),
QXL_RELEASE_RING_SIZE, 0, true,
NULL);
/* TODO - slot initialization should happen on reset. where is our
* reset handler? */
qdev->n_mem_slots = qdev->rom->slots_end;
qdev->slot_gen_bits = qdev->rom->slot_gen_bits;
qdev->slot_id_bits = qdev->rom->slot_id_bits;
qdev->va_slot_mask =
(~(uint64_t)0) >> (qdev->slot_id_bits + qdev->slot_gen_bits);
qdev->mem_slots =
kmalloc(qdev->n_mem_slots * sizeof(struct qxl_memslot),
GFP_KERNEL);
idr_init(&qdev->release_idr);
spin_lock_init(&qdev->release_idr_lock);
spin_lock_init(&qdev->release_lock);
idr_init(&qdev->surf_id_idr);
spin_lock_init(&qdev->surf_id_idr_lock);
mutex_init(&qdev->async_io_mutex);
/* reset the device into a known state - no memslots, no primary
* created, no surfaces. */
qxl_io_reset(qdev);
/* must initialize irq before first async io - slot creation */
r = qxl_irq_init(qdev);
if (r)
return r;
/*
* Note that virtual is surface0. We rely on the single ioremap done
* before.
*/
qdev->main_mem_slot = setup_slot(qdev, 0,
(unsigned long)qdev->vram_base,
(unsigned long)qdev->vram_base + qdev->rom->ram_header_offset);
qdev->surfaces_mem_slot = setup_slot(qdev, 1,
(unsigned long)qdev->surfaceram_base,
(unsigned long)qdev->surfaceram_base + qdev->surfaceram_size);
DRM_INFO("main mem slot %d [%lx,%x]\n",
qdev->main_mem_slot,
(unsigned long)qdev->vram_base, qdev->rom->ram_header_offset);
DRM_INFO("surface mem slot %d [%lx,%lx]\n",
qdev->surfaces_mem_slot,
(unsigned long)qdev->surfaceram_base,
(unsigned long)qdev->surfaceram_size);
qdev->gc_queue = create_singlethread_workqueue("qxl_gc");
INIT_WORK(&qdev->gc_work, qxl_gc_work);
r = qxl_fb_init(qdev);
if (r)
return r;
return 0;
}
开发者ID:020gzh,项目名称:linux,代码行数:101,代码来源:qxl_kms.c
示例9: mxhci_hsic_probe
//.........这里部分代码省略.........
driver->hcd_priv_size = sizeof(struct xhci_hcd *);
xhci->shared_hcd = usb_create_shared_hcd(driver, &pdev->dev,
dev_name(&pdev->dev), hcd);
if (!xhci->shared_hcd) {
ret = -ENOMEM;
goto remove_usb2_hcd;
}
hcd_to_bus(xhci->shared_hcd)->skip_resume = true;
/*
* Set the xHCI pointer before xhci_plat_setup() (aka hcd_driver.reset)
* is called by usb_add_hcd().
*/
*((struct xhci_hcd **) xhci->shared_hcd->hcd_priv) = xhci;
ret = usb_add_hcd(xhci->shared_hcd, irq, IRQF_SHARED);
if (ret)
goto put_usb3_hcd;
spin_lock_init(&mxhci->wakeup_lock);
mxhci->pwr_event_irq = platform_get_irq_byname(pdev, "pwr_event_irq");
if (mxhci->pwr_event_irq < 0) {
dev_err(&pdev->dev,
"platform_get_irq for pwr_event_irq failed\n");
goto remove_usb3_hcd;
}
ret = devm_request_irq(&pdev->dev, mxhci->pwr_event_irq,
mxhci_hsic_pwr_event_irq,
0, "mxhci_hsic_pwr_evt", mxhci);
if (ret) {
dev_err(&pdev->dev, "request irq failed (pwr event irq)\n");
goto remove_usb3_hcd;
}
init_completion(&mxhci->phy_in_lpm);
mxhci->wq = create_singlethread_workqueue("mxhci_wq");
if (!mxhci->wq) {
dev_err(&pdev->dev, "unable to create workqueue\n");
ret = -ENOMEM;
goto remove_usb3_hcd;
}
INIT_WORK(&mxhci->bus_vote_w, mxhci_hsic_bus_vote_w);
mxhci->bus_scale_table = msm_bus_cl_get_pdata(pdev);
if (!mxhci->bus_scale_table) {
dev_dbg(&pdev->dev, "bus scaling is disabled\n");
} else {
mxhci->bus_perf_client =
msm_bus_scale_register_client(mxhci->bus_scale_table);
/* Configure BUS performance parameters for MAX bandwidth */
if (mxhci->bus_perf_client) {
mxhci->bus_vote = true;
queue_work(mxhci->wq, &mxhci->bus_vote_w);
} else {
dev_err(&pdev->dev, "%s: bus scaling client reg err\n",
__func__);
ret = -ENODEV;
goto delete_wq;
}
}
ret = device_create_file(&pdev->dev, &dev_attr_config_imod);
if (ret)
dev_dbg(&pdev->dev, "%s: unable to create imod sysfs entry\n",
__func__);
/* Enable HSIC PHY */
mxhci_hsic_ulpi_write(mxhci, 0x01, MSM_HSIC_CFG_SET);
device_init_wakeup(&pdev->dev, 1);
wakeup_source_init(&mxhci->ws, dev_name(&pdev->dev));
pm_stay_awake(mxhci->dev);
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
return 0;
delete_wq:
destroy_workqueue(mxhci->wq);
remove_usb3_hcd:
usb_remove_hcd(xhci->shared_hcd);
put_usb3_hcd:
usb_put_hcd(xhci->shared_hcd);
remove_usb2_hcd:
usb_remove_hcd(hcd);
deinit_vddcx:
mxhci_hsic_init_vddcx(mxhci, 0);
deinit_clocks:
mxhci_hsic_init_clocks(mxhci, 0);
put_hcd:
usb_put_hcd(hcd);
return ret;
}
开发者ID:AD5GB,项目名称:wicked_kernel_lge_hammerhead,代码行数:101,代码来源:xhci-msm-hsic.c
示例10: cypress_touchkey_probe
//.........这里部分代码省略.........
err = -EIO;
dev_err(dev, "%s: error reading hardware version\n", __func__);
goto err_read;
}
dev_info(dev, "%s: hardware rev1 = %#02x, rev2 = %#02x\n", __func__,
data[1], data[2]);
devdata->backlight_on = BACKLIGHT_ON;
devdata->backlight_off = BACKLIGHT_OFF;
devdata->has_legacy_keycode = 1;
err = i2c_touchkey_write_byte(devdata, devdata->backlight_on);
if (err) {
dev_err(dev, "%s: touch keypad backlight on failed\n",
__func__);
goto err_backlight_on;
}
if (request_threaded_irq(client->irq, touchkey_interrupt_handler,
touchkey_interrupt_thread, IRQF_TRIGGER_FALLING,
DEVICE_NAME, devdata)) {
dev_err(dev, "%s: Can't allocate irq.\n", __func__);
goto err_req_irq;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
devdata->early_suspend.suspend = cypress_touchkey_early_suspend;
devdata->early_suspend.resume = cypress_touchkey_early_resume;
#endif
register_early_suspend(&devdata->early_suspend);
devdata->is_powering_on = false;
#if defined(TOUCH_UPDATE)
ret = misc_register(&touchkey_update_device);
if (ret) {
printk("%s misc_register fail\n", __FUNCTION__);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_touch_version) < 0) {
printk("%s device_create_file fail dev_attr_touch_version\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_version.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_touch_update) < 0) {
printk("%s device_create_file fail dev_attr_touch_update\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_touch_update.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device, &dev_attr_brightness) < 0) {
printk("%s device_create_file fail dev_attr_touch_update\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_brightness.attr.name);
}
if (device_create_file
(touchkey_update_device.this_device,
&dev_attr_enable_disable) < 0) {
printk("%s device_create_file fail dev_attr_touch_update\n",
__FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_enable_disable.attr.name);
}
touchkey_wq = create_singlethread_workqueue(DEVICE_NAME);
if (!touchkey_wq)
return -ENOMEM;
while (retry--) {
if (get_touchkey_firmware(data) == 0) //melfas need delay for multiple read
break;
}
printk("%s F/W version: 0x%x, Module version:0x%x\n", __FUNCTION__,
data[1], data[2]);
#endif
return 0;
err_req_irq:
err_backlight_on:
err_read:
devdata->pdata->touchkey_onoff(TOUCHKEY_OFF);
input_unregister_device(input_dev);
goto err_input_alloc_dev;
err_input_reg_dev:
input_free_device(input_dev);
err_input_alloc_dev:
err_null_keycodes:
kfree(devdata);
return err;
}
开发者ID:Hero355,项目名称:bdroid,代码行数:101,代码来源:cypress-touchkey.c
示例11: al3010_probe
static int __devinit al3010_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct al3010_data *data;
int err = 0;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
return -EIO;
data = kzalloc(sizeof(struct al3010_data), GFP_KERNEL);
if (!data)
return -ENOMEM;
data->client = client;
i2c_set_clientdata(client, data);
mutex_init(&data->lock);
/* initialize the AL3010 chip */
//err = al3010_init_client(client);
//if (err){
//printk("light sensor err : al3010 init fail in probe \n");
//goto exit_kfree;
//}
/* register sysfs hooks */
err = sysfs_create_group(&client->dev.kobj, &al3010_attr_group);
if (err){
printk("light sensor err : al3010 init sysfs fail\n");
goto exit_kfree;
}
/* register device node */
printk("light sensor info : al3010 probe successed\n");
dev_info(&client->dev, "driver version %s enabled\n", DRIVER_VERSION);
/* init for i2c stress test */
sensor_work_queue = create_singlethread_workqueue("i2c_lightsensor_wq");
if(!sensor_work_queue){
printk("al3010_probe: Unable to create workqueue");
goto exit_kfree;
}
INIT_DELAYED_WORK(&al3010_poll_data_work, al3010_poll_data);
al3010_client = client;
data->misc_dev.minor = MISC_DYNAMIC_MINOR;
data->misc_dev.name = "lightsensor";
data->misc_dev.fops = &al3010_fops;
err = misc_register(&data->misc_dev);
if (err){
printk("light sensor err : Unable to register %s\misc device\n",
data->misc_dev.name);
goto exit_kfree;
}
return 0;
exit_kfree:
kfree(data);
return err;
}
开发者ID:CSick,项目名称:kernel_tf700t_jb-mr1-t30-r1,代码行数:61,代码来源:al3010.c
示例12: diagfwd_bridge_init
void diagfwd_bridge_init(void)
{
int ret;
pr_debug("diag: in %s\n", __func__);
driver->diag_bridge_wq = create_singlethread_workqueue(
"diag_bridge_wq");
driver->read_len_mdm = 0;
driver->write_len_mdm = 0;
driver->num_hsic_buf_tbl_entries = 0;
if (driver->usb_buf_mdm_out == NULL)
driver->usb_buf_mdm_out = kzalloc(USB_MAX_OUT_BUF,
GFP_KERNEL);
if (driver->usb_buf_mdm_out == NULL)
goto err;
/* Only used by smux move to smux probe function */
if (driver->write_ptr_mdm == NULL)
driver->write_ptr_mdm = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->write_ptr_mdm == NULL)
goto err;
if (driver->usb_read_mdm_ptr == NULL)
driver->usb_read_mdm_ptr = kzalloc(
sizeof(struct diag_request), GFP_KERNEL);
if (driver->usb_read_mdm_ptr == NULL)
goto err;
if (driver->hsic_buf_tbl == NULL)
driver->hsic_buf_tbl = kzalloc(NUM_HSIC_BUF_TBL_ENTRIES *
sizeof(struct diag_write_device), GFP_KERNEL);
if (driver->hsic_buf_tbl == NULL)
goto err;
driver->count_hsic_pool = 0;
driver->count_hsic_write_pool = 0;
driver->itemsize_hsic = READ_HSIC_BUF_SIZE;
driver->poolsize_hsic = N_MDM_WRITE;
driver->itemsize_hsic_write = sizeof(struct diag_request);
driver->poolsize_hsic_write = N_MDM_WRITE;
#ifdef CONFIG_DIAG_OVER_USB
INIT_WORK(&(driver->diag_read_mdm_work), diag_read_mdm_work_fn);
#endif
INIT_WORK(&(driver->diag_disconnect_work), diag_disconnect_work_fn);
INIT_WORK(&(driver->diag_usb_read_complete_work),
diag_usb_read_complete_fn);
#ifdef CONFIG_DIAG_OVER_USB
driver->mdm_ch = usb_diag_open(DIAG_MDM, driver,
diagfwd_bridge_notifier);
if (IS_ERR(driver->mdm_ch)) {
pr_err("diag: Unable to open USB diag MDM channel\n");
goto err;
}
#endif
/* register HSIC device */
ret = platform_driver_register(&msm_hsic_ch_driver);
if (ret)
pr_err("diag: could not register HSIC device, ret: %d\n", ret);
/* register SMUX device */
ret = platform_driver_register(&msm_diagfwd_smux_driver);
if (ret)
pr_err("diag: could not register SMUX device, ret: %d\n", ret);
return;
err:
pr_err("diag: Could not initialize for bridge forwarding\n");
kfree(driver->usb_buf_mdm_out);
kfree(driver->hsic_buf_tbl);
kfree(driver->write_ptr_mdm);
kfree(driver->usb_read_mdm_ptr);
if (driver->diag_bridge_wq)
destroy_workqueue(driver->diag_bridge_wq);
return;
}
开发者ID:ISTweak,项目名称:android_kernel_sony_blue_hayabusa,代码行数:76,代码来源:diagfwd_hsic.c
示例13: __diag_socket_init
static void __diag_socket_init(struct diag_socket_info *info)
{
uint16_t ins_base = 0;
uint16_t ins_offset = 0;
char wq_name[DIAG_SOCKET_NAME_SZ + 10];
if (!info)
return;
init_waitqueue_head(&info->wait_q);
info->inited = 0;
atomic_set(&info->opened, 0);
atomic_set(&info->diag_state, 0);
info->pkt_len = 0;
info->pkt_read = 0;
info->hdl = NULL;
info->fwd_ctxt = NULL;
info->data_ready = 0;
atomic_set(&info->flow_cnt, 0);
spin_lock_init(&info->lock);
strlcpy(wq_name, "DIAG_SOCKET_", 10);
strlcat(wq_name, info->name, sizeof(info->name));
init_waitqueue_head(&info->read_wait_q);
info->wq = create_singlethread_workqueue(wq_name);
if (!info->wq) {
pr_err("diag: In %s, unable to create workqueue for socket channel %s\n",
__func__, info->name);
return;
}
INIT_WORK(&(info->init_work), socket_init_work_fn);
INIT_WORK(&(info->read_work), socket_read_work_fn);
switch (info->peripheral) {
case PERIPHERAL_MODEM:
ins_base = MODEM_INST_BASE;
break;
case PERIPHERAL_LPASS:
ins_base = LPASS_INST_BASE;
break;
case PERIPHERAL_WCNSS:
ins_base = WCNSS_INST_BASE;
break;
case PERIPHERAL_SENSORS:
ins_base = SENSORS_INST_BASE;
break;
}
switch (info->type) {
case TYPE_DATA:
ins_offset = INST_ID_DATA;
info->port_type = PORT_TYPE_SERVER;
break;
case TYPE_CNTL:
ins_offset = INST_ID_CNTL;
info->port_type = PORT_TYPE_SERVER;
break;
case TYPE_DCI:
ins_offset = INST_ID_DCI;
info->port_type = PORT_TYPE_SERVER;
break;
case TYPE_CMD:
ins_offset = INST_ID_CMD;
info->port_type = PORT_TYPE_CLIENT;
break;
case TYPE_DCI_CMD:
ins_offset = INST_ID_DCI_CMD;
info->port_type = PORT_TYPE_CLIENT;
break;
}
info->svc_id = DIAG_SVC_ID;
info->ins_id = ins_base + ins_offset;
info->inited = 1;
if (info->port_type == PORT_TYPE_SERVER)
queue_work(info->wq, &(info->init_work));
}
开发者ID:moonlightly,项目名称:NX523J_kernel,代码行数:77,代码来源:diagfwd_socket.c
示例14: hi6559_irq_probe
/*****************************************************************************
函 数 名 : hi6559_irq_probe
功能描述 :
输入参数 : 无
输出参数 : 无
返 回 值 : 无
*****************************************************************************/
static s32 __init hi6559_irq_probe(struct platform_device *pdev)
{
s32 ret = BSP_PMU_OK;
u16 i = 0;
u8 regvalue = 0;
hi6559_irq_data_st = kzalloc(sizeof(*hi6559_irq_data_st), GFP_KERNEL);
if (hi6559_irq_data_st == NULL)
{
pmic_print_error("hi6559 irq kzalloc is failed,please check!\n");
return -ENOMEM;
}
hi6559_irq_data_st->irq = (unsigned)platform_get_irq(pdev, 0);
spin_lock_init(&hi6559_irq_data_st->irq_lock);/*中断只在Acore实现,多core*/
/* 初始化工作队列 */
hi6559_irq_data_st->hi6559_irq_wq = create_singlethread_workqueue("bsp_hi6559_irq");
INIT_WORK(&hi6559_irq_data_st->hi6559_irq_wk, (void *)hi6559_irq_wk_handler);
/* 处理usb拔出误报,若usb不在位,多报usb拔出无影响 */
bsp_hi6559_reg_read(HI6559_IRQ2_OFFSET, ®value);
if((regvalue & (0x01 << 2)) && hi6559_usb_state_get())
{
bsp_hi6559_reg_write(HI6559_IRQ2_OFFSET, 0x04);
}
/* 清除所有下电中断寄存器 */
for(i = 0;i < HI6559_IRQ_REG_NUM; i++)
{
bsp_hi6559_reg_read(HI6559_IRQ1_OFFSET + i,®value);
bsp_hi6559_reg_write(HI6559_IRQ1_OFFSET + i, regvalue);
}
/* 清除短路过流中断寄存器,这样过流中断位才能消除 */
for(i = 0; i < HI6559_NP_OCP_SCP_REG_NUM; i++)
{
bsp_hi6559_reg_read(HI6559_SCP_RECORD1_OFFSET + i, ®value);
bsp_hi6559_reg_write(HI6559_SCP_RECORD1_OFFSET + i, regvalue);
}
/* 屏蔽所有中断 */
for(i = 0;i < HI6559_IRQ_REG_NUM;i++)
{
bsp_hi6559_reg_write(HI6559_IRQ1_MASK_OFFSET + i, 0xff);
}
/* 中断注册 */
#ifdef CONFIG_MODULE_VIC
ret = bsp_vic_connect(hi6559_irq_data_st->irq, hi6559_irq_handler,(s32)(hi6559_irq_data_st->irq));
if (ret < 0)
{
pmic_print_error("unable to connect PMIC HI6559 IRQ!\n");
goto out;
}
ret = bsp_vic_enable(hi6559_irq_data_st->irq);
if (ret < 0) {
pmic_print_error("enable PMIC HI6559 IRQ error!\n");
goto out;
}
#else
ret = request_irq((hi6559_irq_data_st->irq), hi6559_irq_handler, IRQF_DISABLED,
"hi6559_irq", hi6559_irq_data_st);
if (ret < 0)
{
pmic_print_error("unable to request PMIC HI6559 IRQ!\n");
goto out;
}
#endif
/* 打开所有中断 */
for(i = 0; i < HI6559_IRQ_REG_NUM; i++)
{
bsp_hi6559_reg_write(HI6559_IRQ1_MASK_OFFSET + i, 0x0);
}
platform_set_drvdata(pdev, hi6559_irq_data_st);
pmic_print_error("hi6559_irq_probe ok !\n");
return ret;
out:
kfree(hi6559_irq_data_st);
return ret;
}
开发者ID:samm-git,项目名称:e3372h-vendor-src,代码行数:91,代码来源:irq_hi6559.c
示例15: wiphy_new
struct r92su *r92su_alloc(struct device *main_dev)
{
struct r92su *r92su = NULL;
struct wiphy *wiphy;
int err;
wiphy = wiphy_new(&r92su_cfg80211_ops, sizeof(struct r92su));
if (!wiphy) {
err = -ENOMEM;
goto err_out;
}
r92su = wiphy_priv(wiphy);
r92su->wdev.wiphy = wiphy;
mutex_init(&r92su->lock);
spin_lock_init(&r92su->rx_path);
if (modparam_noht)
r92su->disable_ht = true;
INIT_LIST_HEAD(&r92su->sta_list);
/* Note: The sta_lock is only needed, if an entry in the
* station list is updated. The station data itself is
* protected by RCU.
*/
spin_lock_init(&r92su->sta_lock);
set_wiphy_dev(r92su->wdev.wiphy, main_dev);
r92su->wdev.iftype = NL80211_IFTYPE_STATION;
wiphy->privid = r92su_priv_id;
wiphy->mgmt_stypes = r92su_default_mgmt_stypes;
wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
BIT(NL80211_IFTYPE_ADHOC) |
BIT(NL80211_IFTYPE_MONITOR);
wiphy->max_scan_ssids = 1;
wiphy->max_scan_ie_len = 256;
wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC;
wiphy->cipher_suites = r92su_chiper_suites;
wiphy->n_cipher_suites = ARRAY_SIZE(r92su_chiper_suites);
wiphy->bss_priv_size = sizeof(struct r92su_bss_priv);
init_completion(&r92su->scan_done);
init_llist_head(&r92su->add_bss_list);
INIT_WORK(&r92su->add_bss_work, r92su_bss_add_work);
INIT_WORK(&r92su->connect_bss_work, r92su_bss_connect_work);
INIT_WORK(&r92su->disconnect_work, r92su_disconnect_work);
INIT_DELAYED_WORK(&r92su->survey_done_work, r92su_survey_done_work);
r92su_hw_init(r92su);
r92su->wq = create_singlethread_workqueue(R92SU_DRVNAME);
if (!r92su->wq) {
err = -ENOMEM;
goto err_out;
}
return r92su;
err_out:
r92su_unregister(r92su);
r92su_free(r92su);
return ERR_PTR(err);
}
开发者ID:UNwS,项目名称:rtl8192su,代码行数:63,代码来源:main.c
示例16: lgx_open
/*====================================
* character device file operations
*===================================*/
static int lgx_open(struct inode* inode, struct file* filp)
{
struct inno_lgx* lgx;
unsigned int lg_num = iminor(inode);
int i;
inno_msg("+++++++++++++++++++++++++++++++++++++++++");
inno_msg("CMMB IF208 open [%s]", lgx_ids_table[lg_num].name);
inno_msg("+++++++++++++++++++++++++++++++++++++++++");
if(lg_num >= LG_END){
inno_err("minor error, should be [%d-%d]", LG0, UAM);
return -1;
}
if(g_inno_dev.lgxs[lg_num]){ //already opened, just increase reference count
down(&g_inno_dev.lgxs[lg_num]->sem);
g_inno_dev.lgxs[lg_num]->use_count++;
//g_inno_dev.lgxs[lg_num]->use_count = 1;
inno_msg("reopen");
up(&g_inno_dev.lgxs[lg_num]->sem);
filp->private_data = g_inno_dev.lgxs[lg_num];
return 0;
}
/* OK, it's not open, Create it */
lgx = (struct inno_lgx*)kmalloc(sizeof(struct inno_lgx), GFP_KERNEL);
if(!lgx){
inno_err("kmalloc lgx ==NULL");
return -1;
}
else
memset(lgx, 0, sizeof(struct inno_lgx));
for(i=0; lgx_ids_table[i].name!=NULL; i++){
if(lg_num == lgx_ids_table[i].id){
lgx->ids = &lgx_ids_table[i];
break;
}
}
//allocat memory for get mfs file
if (lgx_alloc_buffer(lgx)){
kfree(lgx);
lgx = NULL;
return -1;
}
//********** global flag set ******************//
cancle_wait = 0; //xingyu 0328 add solve poll wait
flag_memset = 0; // memset the bitstream buffer
once_closeirq=0; // control close irq
lgx->use_count = 1;
sema_init(&lgx->sem,1);
init_waitqueue_head(&lgx->read_wait);
#ifndef UAM_COMPLETE
init_waitqueue_head(&lgx->uam_wait);
#else
// if(lg_num
|
请发表评论