switch (ie_id) {
                case ATH6KL_FW_IE_FW_VERSION:
-                       strlcpy(ar->wiphy->fw_version, data,
+                       strscpy(ar->wiphy->fw_version, data,
                                min(sizeof(ar->wiphy->fw_version), ie_len+1));
 
                        ath6kl_dbg(ATH6KL_DBG_BOOT,
 
                         CARL9170FW_GET_MONTH(fw_date),
                         CARL9170FW_GET_DAY(fw_date));
 
-               strlcpy(ar->hw->wiphy->fw_version, motd_desc->release,
+               strscpy(ar->hw->wiphy->fw_version, motd_desc->release,
                        sizeof(ar->hw->wiphy->fw_version));
        }
 }
 
                        board_file = WIL_BOARD_FILE_NAME;
        }
 
-       strlcpy(buf, board_file, len);
+       strscpy(buf, board_file, len);
 }
 
 static int wil_get_bl_info(struct wil6210_priv *wil)
 
 
        wil_dbg_misc(wil, "entered");
 
-       strlcpy(wiphy->fw_version, wil->fw_version, sizeof(wiphy->fw_version));
+       strscpy(wiphy->fw_version, wil->fw_version, sizeof(wiphy->fw_version));
 
        rc = wiphy_register(wiphy);
        if (rc < 0) {
 
                return; /* FW load will fail after timeout */
        }
        /* ignore MAC address, we already have it from the boot loader */
-       strlcpy(wiphy->fw_version, wil->fw_version, sizeof(wiphy->fw_version));
+       strscpy(wiphy->fw_version, wil->fw_version, sizeof(wiphy->fw_version));
 
        if (len > offsetof(struct wmi_ready_event, rfc_read_calib_result)) {
                wil_dbg_wmi(wil, "rfc calibration result %d\n",
 
        priv->firmware = NULL;
        priv->firmware_type = fw_type;
        if (firmware) /* module parameter */
-               strlcpy(priv->firmware_id, firmware, sizeof(priv->firmware_id));
+               strscpy(priv->firmware_id, firmware, sizeof(priv->firmware_id));
        priv->bus_type = card_present ? BUS_TYPE_PCCARD : BUS_TYPE_PCI;
        priv->station_state = STATION_STATE_DOWN;
        priv->do_rx_crc = 0;
 
        led->wl = dev->wl;
        led->index = led_index;
        led->activelow = activelow;
-       strlcpy(led->name, name, sizeof(led->name));
+       strscpy(led->name, name, sizeof(led->name));
        atomic_set(&led->state, 0);
 
        led->led_dev.name = led->name;
 
        led->dev = dev;
        led->index = led_index;
        led->activelow = activelow;
-       strlcpy(led->name, name, sizeof(led->name));
+       strscpy(led->name, name, sizeof(led->name));
 
        led->led_dev.name = led->name;
        led->led_dev.default_trigger = default_trigger;
 
                                     &revinfo, sizeof(revinfo));
        if (err < 0) {
                bphy_err(drvr, "retrieving revision info failed, %d\n", err);
-               strlcpy(ri->chipname, "UNKNOWN", sizeof(ri->chipname));
+               strscpy(ri->chipname, "UNKNOWN", sizeof(ri->chipname));
        } else {
                ri->vendorid = le32_to_cpu(revinfo.vendorid);
                ri->deviceid = le32_to_cpu(revinfo.deviceid);
 
        /* locate firmware version number for ethtool */
        ptr = strrchr(buf, ' ') + 1;
-       strlcpy(ifp->drvr->fwver, ptr, sizeof(ifp->drvr->fwver));
+       strscpy(ifp->drvr->fwver, ptr, sizeof(ifp->drvr->fwver));
 
        /* Query for 'clmver' to get CLM version info from firmware */
        memset(buf, 0, sizeof(buf));
         * if not set then if available use the platform data version. To make
         * sure it gets initialized at all, always copy the module param version
         */
-       strlcpy(brcmf_mp_global.firmware_path, brcmf_firmware_path,
+       strscpy(brcmf_mp_global.firmware_path, brcmf_firmware_path,
                BRCMF_FW_ALTPATH_LEN);
        if ((brcmfmac_pdata) && (brcmfmac_pdata->fw_alternative_path) &&
            (brcmf_mp_global.firmware_path[0] == '\0')) {
-               strlcpy(brcmf_mp_global.firmware_path,
+               strscpy(brcmf_mp_global.firmware_path,
                        brcmfmac_pdata->fw_alternative_path,
                        BRCMF_FW_ALTPATH_LEN);
        }
 
 
        if (drvr->revinfo.result == 0)
                brcmu_dotrev_str(drvr->revinfo.driverrev, drev);
-       strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
-       strlcpy(info->version, drev, sizeof(info->version));
-       strlcpy(info->fw_version, drvr->fwver, sizeof(info->fw_version));
-       strlcpy(info->bus_info, dev_name(drvr->bus_if->dev),
+       strscpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
+       strscpy(info->version, drev, sizeof(info->version));
+       strscpy(info->fw_version, drvr->fwver, sizeof(info->fw_version));
+       strscpy(info->bus_info, dev_name(drvr->bus_if->dev),
                sizeof(info->bus_info));
 }
 
 
                fwnames[j].path[0] = '\0';
                /* check if firmware path is provided by module parameter */
                if (brcmf_mp_global.firmware_path[0] != '\0') {
-                       strlcpy(fwnames[j].path, mp_path,
+                       strscpy(fwnames[j].path, mp_path,
                                BRCMF_FW_NAME_LEN);
 
                        if (end != '/') {
 
                                       struct brcmf_fws_mac_descriptor *desc)
 {
        if (desc == &fws->desc.other)
-               strlcpy(desc->name, "MAC-OTHER", sizeof(desc->name));
+               strscpy(desc->name, "MAC-OTHER", sizeof(desc->name));
        else if (desc->mac_handle)
                scnprintf(desc->name, sizeof(desc->name), "MAC-%d:%d",
                          desc->mac_handle, desc->interface_id);
 
        struct ipw2100_priv *priv = libipw_priv(dev);
        char fw_ver[64], ucode_ver[64];
 
-       strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
-       strlcpy(info->version, DRV_VERSION, sizeof(info->version));
+       strscpy(info->driver, DRV_NAME, sizeof(info->driver));
+       strscpy(info->version, DRV_VERSION, sizeof(info->version));
 
        ipw2100_get_fwversion(priv, fw_ver, sizeof(fw_ver));
        ipw2100_get_ucodeversion(priv, ucode_ver, sizeof(ucode_ver));
        snprintf(info->fw_version, sizeof(info->fw_version), "%s:%d:%s",
                 fw_ver, priv->eeprom_version, ucode_ver);
 
-       strlcpy(info->bus_info, pci_name(priv->pci_dev),
+       strscpy(info->bus_info, pci_name(priv->pci_dev),
                sizeof(info->bus_info));
 }
 
 
        char date[32];
        u32 len;
 
-       strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
-       strlcpy(info->version, DRV_VERSION, sizeof(info->version));
+       strscpy(info->driver, DRV_NAME, sizeof(info->driver));
+       strscpy(info->version, DRV_VERSION, sizeof(info->version));
 
        len = sizeof(vers);
        ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
 
        snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
                 vers, date);
-       strlcpy(info->bus_info, pci_name(p->pci_dev),
+       strscpy(info->bus_info, pci_name(p->pci_dev),
                sizeof(info->bus_info));
 }
 
 
 
        if (count) {
                char *p = buffer;
-               strlcpy(buffer, buf, sizeof(buffer));
+               strscpy(buffer, buf, sizeof(buffer));
                channel = simple_strtoul(p, NULL, 0);
                if (channel)
                        params.channel = channel;
 
        iface = netdev_priv(dev);
        local = iface->local;
 
-       strlcpy(info->driver, "hostap", sizeof(info->driver));
+       strscpy(info->driver, "hostap", sizeof(info->driver));
        snprintf(info->fw_version, sizeof(info->fw_version),
                 "%d.%d.%d", (local->sta_fw_ver >> 16) & 0xff,
                 (local->sta_fw_ver >> 8) & 0xff,
 
                priv->fwrelease >> 16 & 0xff,
                priv->fwrelease >>  8 & 0xff,
                priv->fwrelease       & 0xff);
-       strlcpy(info->driver, "libertas", sizeof(info->driver));
-       strlcpy(info->version, lbs_driver_version, sizeof(info->version));
+       strscpy(info->driver, "libertas", sizeof(info->driver));
+       strscpy(info->version, lbs_driver_version, sizeof(info->version));
 }
 
 /*
 
                return NULL;
 
        wl->monitor_dev->type = ARPHRD_IEEE80211_RADIOTAP;
-       strlcpy(wl->monitor_dev->name, name, IFNAMSIZ);
+       strscpy(wl->monitor_dev->name, name, IFNAMSIZ);
        wl->monitor_dev->netdev_ops = &wilc_wfi_netdev_ops;
        wl->monitor_dev->needs_free_netdev = true;
 
 
                        mac->macinfo.extended_capabilities_len;
        }
 
-       strlcpy(wiphy->fw_version, hw_info->fw_version,
+       strscpy(wiphy->fw_version, hw_info->fw_version,
                sizeof(wiphy->fw_version));
        wiphy->hw_version = hw_info->hw_version;
 
 
                hwinfo->total_rx_chain, hwinfo->total_tx_chain,
                hwinfo->fw_ver);
 
-       strlcpy(hwinfo->fw_version, bld_label, sizeof(hwinfo->fw_version));
+       strscpy(hwinfo->fw_version, bld_label, sizeof(hwinfo->fw_version));
        hwinfo->hw_version = hw_ver;
 
        return 0;
 
        led->dev = dev;
        led->ledpin = ledpin;
        led->is_radio = is_radio;
-       strlcpy(led->name, name, sizeof(led->name));
+       strscpy(led->name, name, sizeof(led->name));
 
        led->led_dev.name = led->name;
        led->led_dev.default_trigger = default_trigger;
 
 static int wl3501_get_name(struct net_device *dev, struct iw_request_info *info,
                           union iwreq_data *wrqu, char *extra)
 {
-       strlcpy(wrqu->name, "IEEE 802.11-DS", sizeof(wrqu->name));
+       strscpy(wrqu->name, "IEEE 802.11-DS", sizeof(wrqu->name));
        return 0;
 }
 
 
        if (wrqu->data.length > sizeof(this->nick))
                return -E2BIG;
-       strlcpy(this->nick, extra, wrqu->data.length);
+       strscpy(this->nick, extra, wrqu->data.length);
        return 0;
 }
 
 {
        struct wl3501_card *this = netdev_priv(dev);
 
-       strlcpy(extra, this->nick, 32);
+       strscpy(extra, this->nick, 32);
        wrqu->data.length = strlen(extra);
        return 0;
 }
        this->firmware_date[0]  = '\0';
        this->rssi              = 255;
        this->chan              = iw_default_channel(this->reg_domain);
-       strlcpy(this->nick, "Planet WL3501", sizeof(this->nick));
+       strscpy(this->nick, "Planet WL3501", sizeof(this->nick));
        spin_lock_init(&this->lock);
        init_waitqueue_head(&this->wait);
        netif_start_queue(dev);