| /* Copyright (c) 2011-2012, Code Aurora Forum. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 and |
| * only version 2 as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/slab.h> |
| #include <linux/err.h> |
| #include <linux/platform_device.h> |
| #include <linux/miscdevice.h> |
| #include <linux/fs.h> |
| #include <linux/wcnss_wlan.h> |
| #include <linux/platform_data/qcom_wcnss_device.h> |
| #include <linux/workqueue.h> |
| #include <linux/jiffies.h> |
| #include <linux/gpio.h> |
| #include <linux/wakelock.h> |
| #include <linux/delay.h> |
| #include <mach/peripheral-loader.h> |
| #include <mach/msm_smd.h> |
| |
| #define DEVICE "wcnss_wlan" |
| #define VERSION "1.01" |
| #define WCNSS_PIL_DEVICE "wcnss" |
| |
| /* module params */ |
| #define WCNSS_CONFIG_UNSPECIFIED (-1) |
| |
| static int has_48mhz_xo = WCNSS_CONFIG_UNSPECIFIED; |
| module_param(has_48mhz_xo, int, S_IWUSR | S_IRUGO); |
| MODULE_PARM_DESC(has_48mhz_xo, "Is an external 48 MHz XO present"); |
| |
| #define WCNSS_CTRL_CHANNEL "WCNSS_CTRL" |
| #define WCNSS_MAX_FRAME_SIZE 500 |
| #define WCNSS_VERSION_LEN 30 |
| |
| /* message types */ |
| #define WCNSS_CTRL_MSG_START 0x01000000 |
| #define WCNSS_VERSION_REQ (WCNSS_CTRL_MSG_START + 0) |
| #define WCNSS_VERSION_RSP (WCNSS_CTRL_MSG_START + 1) |
| |
| #define VALID_VERSION(version) \ |
| ((strncmp(version, "INVALID", WCNSS_VERSION_LEN)) ? 1 : 0) |
| |
| struct smd_msg_hdr { |
| unsigned int type; |
| unsigned int len; |
| }; |
| |
| struct wcnss_version { |
| struct smd_msg_hdr hdr; |
| unsigned char major; |
| unsigned char minor; |
| unsigned char version; |
| unsigned char revision; |
| }; |
| |
| static struct { |
| struct platform_device *pdev; |
| void *pil; |
| struct resource *mmio_res; |
| struct resource *tx_irq_res; |
| struct resource *rx_irq_res; |
| struct resource *gpios_5wire; |
| const struct dev_pm_ops *pm_ops; |
| int triggered; |
| int smd_channel_ready; |
| smd_channel_t *smd_ch; |
| unsigned char wcnss_version[WCNSS_VERSION_LEN]; |
| unsigned int serial_number; |
| int thermal_mitigation; |
| void (*tm_notify)(struct device *, int); |
| struct wcnss_wlan_config wlan_config; |
| struct delayed_work wcnss_work; |
| struct work_struct wcnssctrl_version_work; |
| struct work_struct wcnssctrl_rx_work; |
| struct wake_lock wcnss_wake_lock; |
| } *penv = NULL; |
| |
| static ssize_t wcnss_serial_number_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| if (!penv) |
| return -ENODEV; |
| |
| return scnprintf(buf, PAGE_SIZE, "%08X\n", penv->serial_number); |
| } |
| |
| static ssize_t wcnss_serial_number_store(struct device *dev, |
| struct device_attribute *attr, const char *buf, size_t count) |
| { |
| unsigned int value; |
| |
| if (!penv) |
| return -ENODEV; |
| |
| if (sscanf(buf, "%08X", &value) != 1) |
| return -EINVAL; |
| |
| penv->serial_number = value; |
| return count; |
| } |
| |
| static DEVICE_ATTR(serial_number, S_IRUSR | S_IWUSR, |
| wcnss_serial_number_show, wcnss_serial_number_store); |
| |
| |
| static ssize_t wcnss_thermal_mitigation_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| if (!penv) |
| return -ENODEV; |
| |
| return scnprintf(buf, PAGE_SIZE, "%u\n", penv->thermal_mitigation); |
| } |
| |
| static ssize_t wcnss_thermal_mitigation_store(struct device *dev, |
| struct device_attribute *attr, const char *buf, size_t count) |
| { |
| int value; |
| |
| if (!penv) |
| return -ENODEV; |
| |
| if (sscanf(buf, "%d", &value) != 1) |
| return -EINVAL; |
| penv->thermal_mitigation = value; |
| if (penv->tm_notify) |
| (penv->tm_notify)(dev, value); |
| return count; |
| } |
| |
| static DEVICE_ATTR(thermal_mitigation, S_IRUSR | S_IWUSR, |
| wcnss_thermal_mitigation_show, wcnss_thermal_mitigation_store); |
| |
| |
| static ssize_t wcnss_version_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| if (!penv) |
| return -ENODEV; |
| |
| return scnprintf(buf, PAGE_SIZE, "%s", penv->wcnss_version); |
| } |
| |
| static DEVICE_ATTR(wcnss_version, S_IRUSR, |
| wcnss_version_show, NULL); |
| |
| static int wcnss_create_sysfs(struct device *dev) |
| { |
| int ret; |
| |
| if (!dev) |
| return -ENODEV; |
| |
| ret = device_create_file(dev, &dev_attr_serial_number); |
| if (ret) |
| return ret; |
| |
| ret = device_create_file(dev, &dev_attr_thermal_mitigation); |
| if (ret) |
| goto remove_serial; |
| |
| ret = device_create_file(dev, &dev_attr_wcnss_version); |
| if (ret) |
| goto remove_thermal; |
| |
| return 0; |
| |
| remove_thermal: |
| device_remove_file(dev, &dev_attr_thermal_mitigation); |
| remove_serial: |
| device_remove_file(dev, &dev_attr_serial_number); |
| |
| return ret; |
| } |
| |
| static void wcnss_remove_sysfs(struct device *dev) |
| { |
| if (dev) { |
| device_remove_file(dev, &dev_attr_serial_number); |
| device_remove_file(dev, &dev_attr_thermal_mitigation); |
| device_remove_file(dev, &dev_attr_wcnss_version); |
| } |
| } |
| static void wcnss_smd_notify_event(void *data, unsigned int event) |
| { |
| int len = 0; |
| |
| if (penv != data) { |
| pr_err("wcnss: invalid env pointer in smd callback\n"); |
| return; |
| } |
| switch (event) { |
| case SMD_EVENT_DATA: |
| len = smd_read_avail(penv->smd_ch); |
| if (len < 0) |
| pr_err("wcnss: failed to read from smd %d\n", len); |
| schedule_work(&penv->wcnssctrl_rx_work); |
| break; |
| |
| case SMD_EVENT_OPEN: |
| pr_debug("wcnss: opening WCNSS SMD channel :%s", |
| WCNSS_CTRL_CHANNEL); |
| if (!VALID_VERSION(penv->wcnss_version)) |
| schedule_work(&penv->wcnssctrl_version_work); |
| break; |
| |
| case SMD_EVENT_CLOSE: |
| pr_debug("wcnss: closing WCNSS SMD channel :%s", |
| WCNSS_CTRL_CHANNEL); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| static void wcnss_post_bootup(struct work_struct *work) |
| { |
| pr_info("%s: Cancel APPS vote for Iris & Riva\n", __func__); |
| |
| /* Since Riva is up, cancel any APPS vote for Iris & Riva VREGs */ |
| wcnss_wlan_power(&penv->pdev->dev, &penv->wlan_config, |
| WCNSS_WLAN_SWITCH_OFF); |
| } |
| |
| static int |
| wcnss_gpios_config(struct resource *gpios_5wire, bool enable) |
| { |
| int i, j; |
| int rc = 0; |
| |
| for (i = gpios_5wire->start; i <= gpios_5wire->end; i++) { |
| if (enable) { |
| rc = gpio_request(i, gpios_5wire->name); |
| if (rc) { |
| pr_err("WCNSS gpio_request %d err %d\n", i, rc); |
| goto fail; |
| } |
| } else |
| gpio_free(i); |
| } |
| |
| return rc; |
| |
| fail: |
| for (j = i-1; j >= gpios_5wire->start; j--) |
| gpio_free(j); |
| return rc; |
| } |
| |
| static int __devinit |
| wcnss_wlan_ctrl_probe(struct platform_device *pdev) |
| { |
| if (!penv) |
| return -ENODEV; |
| |
| penv->smd_channel_ready = 1; |
| |
| pr_info("%s: SMD ctrl channel up\n", __func__); |
| |
| /* Schedule a work to do any post boot up activity */ |
| INIT_DELAYED_WORK(&penv->wcnss_work, wcnss_post_bootup); |
| schedule_delayed_work(&penv->wcnss_work, msecs_to_jiffies(10000)); |
| |
| return 0; |
| } |
| |
| void wcnss_flush_delayed_boot_votes() |
| { |
| flush_delayed_work_sync(&penv->wcnss_work); |
| } |
| EXPORT_SYMBOL(wcnss_flush_delayed_boot_votes); |
| |
| static int __devexit |
| wcnss_wlan_ctrl_remove(struct platform_device *pdev) |
| { |
| if (penv) |
| penv->smd_channel_ready = 0; |
| |
| pr_info("%s: SMD ctrl channel down\n", __func__); |
| |
| return 0; |
| } |
| |
| |
| static struct platform_driver wcnss_wlan_ctrl_driver = { |
| .driver = { |
| .name = "WLAN_CTRL", |
| .owner = THIS_MODULE, |
| }, |
| .probe = wcnss_wlan_ctrl_probe, |
| .remove = __devexit_p(wcnss_wlan_ctrl_remove), |
| }; |
| |
| static int __devexit |
| wcnss_ctrl_remove(struct platform_device *pdev) |
| { |
| if (penv && penv->smd_ch) |
| smd_close(penv->smd_ch); |
| |
| return 0; |
| } |
| |
| static int __devinit |
| wcnss_ctrl_probe(struct platform_device *pdev) |
| { |
| int ret = 0; |
| |
| if (!penv) |
| return -ENODEV; |
| |
| ret = smd_named_open_on_edge(WCNSS_CTRL_CHANNEL, SMD_APPS_WCNSS, |
| &penv->smd_ch, penv, wcnss_smd_notify_event); |
| if (ret < 0) { |
| pr_err("wcnss: cannot open the smd command channel %s: %d\n", |
| WCNSS_CTRL_CHANNEL, ret); |
| return -ENODEV; |
| } |
| smd_disable_read_intr(penv->smd_ch); |
| |
| return 0; |
| } |
| |
| /* platform device for WCNSS_CTRL SMD channel */ |
| static struct platform_driver wcnss_ctrl_driver = { |
| .driver = { |
| .name = "WCNSS_CTRL", |
| .owner = THIS_MODULE, |
| }, |
| .probe = wcnss_ctrl_probe, |
| .remove = __devexit_p(wcnss_ctrl_remove), |
| }; |
| |
| struct device *wcnss_wlan_get_device(void) |
| { |
| if (penv && penv->pdev && penv->smd_channel_ready) |
| return &penv->pdev->dev; |
| return NULL; |
| } |
| EXPORT_SYMBOL(wcnss_wlan_get_device); |
| |
| struct platform_device *wcnss_get_platform_device(void) |
| { |
| if (penv && penv->pdev) |
| return penv->pdev; |
| return NULL; |
| } |
| EXPORT_SYMBOL(wcnss_get_platform_device); |
| |
| struct wcnss_wlan_config *wcnss_get_wlan_config(void) |
| { |
| if (penv && penv->pdev) |
| return &penv->wlan_config; |
| return NULL; |
| } |
| EXPORT_SYMBOL(wcnss_get_wlan_config); |
| |
| struct resource *wcnss_wlan_get_memory_map(struct device *dev) |
| { |
| if (penv && dev && (dev == &penv->pdev->dev) && penv->smd_channel_ready) |
| return penv->mmio_res; |
| return NULL; |
| } |
| EXPORT_SYMBOL(wcnss_wlan_get_memory_map); |
| |
| int wcnss_wlan_get_dxe_tx_irq(struct device *dev) |
| { |
| if (penv && dev && (dev == &penv->pdev->dev) && |
| penv->tx_irq_res && penv->smd_channel_ready) |
| return penv->tx_irq_res->start; |
| return WCNSS_WLAN_IRQ_INVALID; |
| } |
| EXPORT_SYMBOL(wcnss_wlan_get_dxe_tx_irq); |
| |
| int wcnss_wlan_get_dxe_rx_irq(struct device *dev) |
| { |
| if (penv && dev && (dev == &penv->pdev->dev) && |
| penv->rx_irq_res && penv->smd_channel_ready) |
| return penv->rx_irq_res->start; |
| return WCNSS_WLAN_IRQ_INVALID; |
| } |
| EXPORT_SYMBOL(wcnss_wlan_get_dxe_rx_irq); |
| |
| void wcnss_wlan_register_pm_ops(struct device *dev, |
| const struct dev_pm_ops *pm_ops) |
| { |
| if (penv && dev && (dev == &penv->pdev->dev) && pm_ops) |
| penv->pm_ops = pm_ops; |
| } |
| EXPORT_SYMBOL(wcnss_wlan_register_pm_ops); |
| |
| void wcnss_wlan_unregister_pm_ops(struct device *dev, |
| const struct dev_pm_ops *pm_ops) |
| { |
| if (penv && dev && (dev == &penv->pdev->dev) && pm_ops) { |
| if (pm_ops->suspend != penv->pm_ops->suspend || |
| pm_ops->resume != penv->pm_ops->resume) |
| pr_err("PM APIs dont match with registered APIs\n"); |
| penv->pm_ops = NULL; |
| } |
| } |
| EXPORT_SYMBOL(wcnss_wlan_unregister_pm_ops); |
| |
| void wcnss_register_thermal_mitigation(struct device *dev, |
| void (*tm_notify)(struct device *, int)) |
| { |
| if (penv && dev && tm_notify) |
| penv->tm_notify = tm_notify; |
| } |
| EXPORT_SYMBOL(wcnss_register_thermal_mitigation); |
| |
| void wcnss_unregister_thermal_mitigation( |
| void (*tm_notify)(struct device *, int)) |
| { |
| if (penv && tm_notify) { |
| if (tm_notify != penv->tm_notify) |
| pr_err("tm_notify doesn't match registered\n"); |
| penv->tm_notify = NULL; |
| } |
| } |
| EXPORT_SYMBOL(wcnss_unregister_thermal_mitigation); |
| |
| unsigned int wcnss_get_serial_number(void) |
| { |
| if (penv) |
| return penv->serial_number; |
| return 0; |
| } |
| EXPORT_SYMBOL(wcnss_get_serial_number); |
| |
| static int wcnss_wlan_suspend(struct device *dev) |
| { |
| if (penv && dev && (dev == &penv->pdev->dev) && |
| penv->smd_channel_ready && |
| penv->pm_ops && penv->pm_ops->suspend) |
| return penv->pm_ops->suspend(dev); |
| return 0; |
| } |
| |
| static int wcnss_wlan_resume(struct device *dev) |
| { |
| if (penv && dev && (dev == &penv->pdev->dev) && |
| penv->smd_channel_ready && |
| penv->pm_ops && penv->pm_ops->resume) |
| return penv->pm_ops->resume(dev); |
| return 0; |
| } |
| |
| void wcnss_prevent_suspend() |
| { |
| if (penv) |
| wake_lock(&penv->wcnss_wake_lock); |
| } |
| EXPORT_SYMBOL(wcnss_prevent_suspend); |
| |
| void wcnss_allow_suspend() |
| { |
| if (penv) |
| wake_unlock(&penv->wcnss_wake_lock); |
| } |
| EXPORT_SYMBOL(wcnss_allow_suspend); |
| |
| static int wcnss_smd_tx(void *data, int len) |
| { |
| int ret = 0; |
| |
| ret = smd_write_avail(penv->smd_ch); |
| if (ret < len) { |
| pr_err("wcnss: no space available for smd frame\n"); |
| ret = -ENOSPC; |
| } |
| ret = smd_write(penv->smd_ch, data, len); |
| if (ret < len) { |
| pr_err("wcnss: failed to write Command %d", len); |
| ret = -ENODEV; |
| } |
| return ret; |
| } |
| |
| static void wcnssctrl_rx_handler(struct work_struct *worker) |
| { |
| int len = 0; |
| int rc = 0; |
| unsigned char buf[WCNSS_MAX_FRAME_SIZE]; |
| struct smd_msg_hdr *phdr; |
| struct wcnss_version *pversion; |
| |
| len = smd_read_avail(penv->smd_ch); |
| if (len > WCNSS_MAX_FRAME_SIZE) { |
| pr_err("wcnss: frame larger than the allowed size\n"); |
| smd_read(penv->smd_ch, NULL, len); |
| return; |
| } |
| if (len <= 0) |
| return; |
| |
| rc = smd_read(penv->smd_ch, buf, len); |
| if (rc < len) { |
| pr_err("wcnss: incomplete data read from smd\n"); |
| return; |
| } |
| |
| phdr = (struct smd_msg_hdr *)buf; |
| |
| switch (phdr->type) { |
| |
| case WCNSS_VERSION_RSP: |
| pversion = (struct wcnss_version *)buf; |
| if (len != sizeof(struct wcnss_version)) { |
| pr_err("wcnss: invalid version data from wcnss %d\n", |
| len); |
| return; |
| } |
| snprintf(penv->wcnss_version, WCNSS_VERSION_LEN, |
| "%02x%02x%02x%02x", pversion->major, pversion->minor, |
| pversion->version, pversion->revision); |
| pr_info("wcnss: version %s\n", penv->wcnss_version); |
| break; |
| |
| default: |
| pr_err("wcnss: invalid message type %d\n", phdr->type); |
| } |
| return; |
| } |
| |
| static void wcnss_send_version_req(struct work_struct *worker) |
| { |
| struct smd_msg_hdr smd_msg; |
| int ret = 0; |
| |
| smd_msg.type = WCNSS_VERSION_REQ; |
| smd_msg.len = sizeof(smd_msg); |
| ret = wcnss_smd_tx(&smd_msg, smd_msg.len); |
| if (ret < 0) |
| pr_err("wcnss: smd tx failed\n"); |
| |
| return; |
| } |
| |
| static int |
| wcnss_trigger_config(struct platform_device *pdev) |
| { |
| int ret; |
| struct qcom_wcnss_opts *pdata; |
| |
| /* make sure we are only triggered once */ |
| if (penv->triggered) |
| return 0; |
| penv->triggered = 1; |
| |
| /* initialize the WCNSS device configuration */ |
| pdata = pdev->dev.platform_data; |
| if (WCNSS_CONFIG_UNSPECIFIED == has_48mhz_xo) |
| has_48mhz_xo = pdata->has_48mhz_xo; |
| penv->wlan_config.use_48mhz_xo = has_48mhz_xo; |
| |
| penv->thermal_mitigation = 0; |
| strlcpy(penv->wcnss_version, "INVALID", WCNSS_VERSION_LEN); |
| |
| penv->gpios_5wire = platform_get_resource_byname(pdev, IORESOURCE_IO, |
| "wcnss_gpios_5wire"); |
| |
| /* allocate 5-wire GPIO resources */ |
| if (!penv->gpios_5wire) { |
| dev_err(&pdev->dev, "insufficient IO resources\n"); |
| ret = -ENOENT; |
| goto fail_gpio_res; |
| } |
| |
| /* Configure 5 wire GPIOs */ |
| ret = wcnss_gpios_config(penv->gpios_5wire, true); |
| if (ret) { |
| dev_err(&pdev->dev, "WCNSS gpios config failed.\n"); |
| goto fail_gpio_res; |
| } |
| |
| /* power up the WCNSS */ |
| ret = wcnss_wlan_power(&pdev->dev, &penv->wlan_config, |
| WCNSS_WLAN_SWITCH_ON); |
| if (ret) { |
| dev_err(&pdev->dev, "WCNSS Power-up failed.\n"); |
| goto fail_power; |
| } |
| |
| /* trigger initialization of the WCNSS */ |
| penv->pil = pil_get(WCNSS_PIL_DEVICE); |
| if (IS_ERR(penv->pil)) { |
| dev_err(&pdev->dev, "Peripheral Loader failed on WCNSS.\n"); |
| ret = PTR_ERR(penv->pil); |
| penv->pil = NULL; |
| goto fail_pil; |
| } |
| |
| /* allocate resources */ |
| penv->mmio_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, |
| "wcnss_mmio"); |
| penv->tx_irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, |
| "wcnss_wlantx_irq"); |
| penv->rx_irq_res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, |
| "wcnss_wlanrx_irq"); |
| |
| if (!(penv->mmio_res && penv->tx_irq_res && penv->rx_irq_res)) { |
| dev_err(&pdev->dev, "insufficient resources\n"); |
| ret = -ENOENT; |
| goto fail_res; |
| } |
| INIT_WORK(&penv->wcnssctrl_rx_work, wcnssctrl_rx_handler); |
| INIT_WORK(&penv->wcnssctrl_version_work, wcnss_send_version_req); |
| |
| wake_lock_init(&penv->wcnss_wake_lock, WAKE_LOCK_SUSPEND, "wcnss"); |
| |
| return 0; |
| |
| fail_res: |
| if (penv->pil) |
| pil_put(penv->pil); |
| fail_pil: |
| wcnss_wlan_power(&pdev->dev, &penv->wlan_config, |
| WCNSS_WLAN_SWITCH_OFF); |
| fail_power: |
| wcnss_gpios_config(penv->gpios_5wire, false); |
| fail_gpio_res: |
| kfree(penv); |
| penv = NULL; |
| return ret; |
| } |
| |
| #ifndef MODULE |
| static int wcnss_node_open(struct inode *inode, struct file *file) |
| { |
| struct platform_device *pdev; |
| |
| pr_info(DEVICE " triggered by userspace\n"); |
| |
| pdev = penv->pdev; |
| return wcnss_trigger_config(pdev); |
| } |
| |
| static const struct file_operations wcnss_node_fops = { |
| .owner = THIS_MODULE, |
| .open = wcnss_node_open, |
| }; |
| |
| static struct miscdevice wcnss_misc = { |
| .minor = MISC_DYNAMIC_MINOR, |
| .name = DEVICE, |
| .fops = &wcnss_node_fops, |
| }; |
| #endif /* ifndef MODULE */ |
| |
| |
| static int __devinit |
| wcnss_wlan_probe(struct platform_device *pdev) |
| { |
| int ret = 0; |
| |
| /* verify we haven't been called more than once */ |
| if (penv) { |
| dev_err(&pdev->dev, "cannot handle multiple devices.\n"); |
| return -ENODEV; |
| } |
| |
| /* create an environment to track the device */ |
| penv = kzalloc(sizeof(*penv), GFP_KERNEL); |
| if (!penv) { |
| dev_err(&pdev->dev, "cannot allocate device memory.\n"); |
| return -ENOMEM; |
| } |
| penv->pdev = pdev; |
| |
| /* register sysfs entries */ |
| ret = wcnss_create_sysfs(&pdev->dev); |
| if (ret) |
| return -ENOENT; |
| |
| |
| #ifdef MODULE |
| |
| /* |
| * Since we were built as a module, we are running because |
| * the module was loaded, therefore we assume userspace |
| * applications are available to service PIL, so we can |
| * trigger the WCNSS configuration now |
| */ |
| pr_info(DEVICE " probed in MODULE mode\n"); |
| return wcnss_trigger_config(pdev); |
| |
| #else |
| |
| /* |
| * Since we were built into the kernel we'll be called as part |
| * of kernel initialization. We don't know if userspace |
| * applications are available to service PIL at this time |
| * (they probably are not), so we simply create a device node |
| * here. When userspace is available it should touch the |
| * device so that we know that WCNSS configuration can take |
| * place |
| */ |
| pr_info(DEVICE " probed in built-in mode\n"); |
| return misc_register(&wcnss_misc); |
| |
| #endif |
| } |
| |
| static int __devexit |
| wcnss_wlan_remove(struct platform_device *pdev) |
| { |
| wcnss_remove_sysfs(&pdev->dev); |
| return 0; |
| } |
| |
| |
| static const struct dev_pm_ops wcnss_wlan_pm_ops = { |
| .suspend = wcnss_wlan_suspend, |
| .resume = wcnss_wlan_resume, |
| }; |
| |
| static struct platform_driver wcnss_wlan_driver = { |
| .driver = { |
| .name = DEVICE, |
| .owner = THIS_MODULE, |
| .pm = &wcnss_wlan_pm_ops, |
| }, |
| .probe = wcnss_wlan_probe, |
| .remove = __devexit_p(wcnss_wlan_remove), |
| }; |
| |
| static int __init wcnss_wlan_init(void) |
| { |
| platform_driver_register(&wcnss_wlan_driver); |
| platform_driver_register(&wcnss_wlan_ctrl_driver); |
| platform_driver_register(&wcnss_ctrl_driver); |
| |
| return 0; |
| } |
| |
| static void __exit wcnss_wlan_exit(void) |
| { |
| if (penv) { |
| if (penv->pil) |
| pil_put(penv->pil); |
| |
| |
| kfree(penv); |
| penv = NULL; |
| } |
| |
| platform_driver_unregister(&wcnss_ctrl_driver); |
| platform_driver_unregister(&wcnss_wlan_ctrl_driver); |
| platform_driver_unregister(&wcnss_wlan_driver); |
| } |
| |
| module_init(wcnss_wlan_init); |
| module_exit(wcnss_wlan_exit); |
| |
| MODULE_LICENSE("GPL v2"); |
| MODULE_VERSION(VERSION); |
| MODULE_DESCRIPTION(DEVICE "Driver"); |