driver core update for 4.4-rc1
Here's the "big" driver core updates for 4.4-rc1. Primarily a bunch of debugfs updates, with a smattering of minor driver core fixes and updates as well. All have been in linux-next for a long time. Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> -----BEGIN PGP SIGNATURE----- Version: GnuPG v2 iEYEABECAAYFAlY6ePQACgkQMUfUDdst+ymNTgCgpP0CZw57GpwF/Hp2L/lMkVeo Kx8AoKhEi4iqD5fdCQS9qTfomB+2/M6g =g7ZO -----END PGP SIGNATURE----- Merge tag 'driver-core-4.4-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core Pull driver core updates from Greg KH: "Here's the "big" driver core updates for 4.4-rc1. Primarily a bunch of debugfs updates, with a smattering of minor driver core fixes and updates as well. All have been in linux-next for a long time" * tag 'driver-core-4.4-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core: debugfs: Add debugfs_create_ulong() of: to support binding numa node to specified device in devicetree debugfs: Add read-only/write-only bool file ops debugfs: Add read-only/write-only size_t file ops debugfs: Add read-only/write-only x64 file ops debugfs: Consolidate file mode checks in debugfs_create_*() Revert "mm: Check if section present during memory block (un)registering" driver-core: platform: Provide helpers for multi-driver modules mm: Check if section present during memory block (un)registering devres: fix a for loop bounds check CMA: fix CONFIG_CMA_SIZE_MBYTES overflow in 64bit base/platform: assert that dev_pm_domain callbacks are called unconditionally sysfs: correctly handle short reads on PREALLOC attrs. base: soc: siplify ida usage kobject: move EXPORT_SYMBOL() macros next to corresponding definitions kobject: explain what kobject's sd field is debugfs: document that debugfs_remove*() accepts NULL and error values debugfs: Pass bool pointer to debugfs_create_bool() ACPI / EC: Fix broken 64bit big-endian users of 'global_lock'hifive-unleashed-5.1
Linus Torvalds
commit
e880e87488
|
|
@ -63,6 +63,20 @@ runtime memory footprint:
|
|||
int platform_driver_probe(struct platform_driver *drv,
|
||||
int (*probe)(struct platform_device *))
|
||||
|
||||
Kernel modules can be composed of several platform drivers. The platform core
|
||||
provides helpers to register and unregister an array of drivers:
|
||||
|
||||
int __platform_register_drivers(struct platform_driver * const *drivers,
|
||||
unsigned int count, struct module *owner);
|
||||
void platform_unregister_drivers(struct platform_driver * const *drivers,
|
||||
unsigned int count);
|
||||
|
||||
If one of the drivers fails to register, all drivers registered up to that
|
||||
point will be unregistered in reverse order. Note that there is a convenience
|
||||
macro that passes THIS_MODULE as owner parameter:
|
||||
|
||||
#define platform_register_driver(drivers, count)
|
||||
|
||||
|
||||
Device Enumeration
|
||||
~~~~~~~~~~~~~~~~~~
|
||||
|
|
|
|||
|
|
@ -105,7 +105,7 @@ a variable of type size_t.
|
|||
Boolean values can be placed in debugfs with:
|
||||
|
||||
struct dentry *debugfs_create_bool(const char *name, umode_t mode,
|
||||
struct dentry *parent, u32 *value);
|
||||
struct dentry *parent, bool *value);
|
||||
|
||||
A read on the resulting file will yield either Y (for non-zero values) or
|
||||
N, followed by a newline. If written to, it will accept either upper- or
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@ static u32 mdscr_read(void)
|
|||
* Allow root to disable self-hosted debug from userspace.
|
||||
* This is useful if you want to connect an external JTAG debugger.
|
||||
*/
|
||||
static u32 debug_enabled = 1;
|
||||
static bool debug_enabled = true;
|
||||
|
||||
static int create_debug_debugfs_entry(void)
|
||||
{
|
||||
|
|
@ -71,7 +71,7 @@ fs_initcall(create_debug_debugfs_entry);
|
|||
|
||||
static int __init early_debug_disable(char *buf)
|
||||
{
|
||||
debug_enabled = 0;
|
||||
debug_enabled = false;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -128,7 +128,7 @@ static int acpi_ec_add_debugfs(struct acpi_ec *ec, unsigned int ec_device_count)
|
|||
if (!debugfs_create_x32("gpe", 0444, dev_dir, (u32 *)&first_ec->gpe))
|
||||
goto error;
|
||||
if (!debugfs_create_bool("use_global_lock", 0444, dev_dir,
|
||||
(u32 *)&first_ec->global_lock))
|
||||
&first_ec->global_lock))
|
||||
goto error;
|
||||
|
||||
if (write_support)
|
||||
|
|
|
|||
|
|
@ -138,7 +138,7 @@ struct acpi_ec {
|
|||
unsigned long gpe;
|
||||
unsigned long command_addr;
|
||||
unsigned long data_addr;
|
||||
unsigned long global_lock;
|
||||
bool global_lock;
|
||||
unsigned long flags;
|
||||
unsigned long reference_count;
|
||||
struct mutex mutex;
|
||||
|
|
|
|||
|
|
@ -1066,7 +1066,7 @@ int device_add(struct device *dev)
|
|||
dev->kobj.parent = kobj;
|
||||
|
||||
/* use parent numa_node */
|
||||
if (parent)
|
||||
if (parent && (dev_to_node(dev) == NUMA_NO_NODE))
|
||||
set_dev_node(dev, dev_to_node(parent));
|
||||
|
||||
/* first, register with generic layer. */
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ struct cma *dma_contiguous_default_area;
|
|||
* Users, who want to set the size of global CMA area for their system
|
||||
* should use cma= kernel parameter.
|
||||
*/
|
||||
static const phys_addr_t size_bytes = CMA_SIZE_MBYTES * SZ_1M;
|
||||
static const phys_addr_t size_bytes = (phys_addr_t)CMA_SIZE_MBYTES * SZ_1M;
|
||||
static phys_addr_t size_cmdline = -1;
|
||||
static phys_addr_t base_cmdline;
|
||||
static phys_addr_t limit_cmdline;
|
||||
|
|
|
|||
|
|
@ -513,7 +513,7 @@ static int platform_drv_probe(struct device *_dev)
|
|||
return ret;
|
||||
|
||||
ret = dev_pm_domain_attach(_dev, true);
|
||||
if (ret != -EPROBE_DEFER) {
|
||||
if (ret != -EPROBE_DEFER && drv->probe) {
|
||||
ret = drv->probe(dev);
|
||||
if (ret)
|
||||
dev_pm_domain_detach(_dev, true);
|
||||
|
|
@ -536,9 +536,10 @@ static int platform_drv_remove(struct device *_dev)
|
|||
{
|
||||
struct platform_driver *drv = to_platform_driver(_dev->driver);
|
||||
struct platform_device *dev = to_platform_device(_dev);
|
||||
int ret;
|
||||
int ret = 0;
|
||||
|
||||
ret = drv->remove(dev);
|
||||
if (drv->remove)
|
||||
ret = drv->remove(dev);
|
||||
dev_pm_domain_detach(_dev, true);
|
||||
|
||||
return ret;
|
||||
|
|
@ -549,7 +550,8 @@ static void platform_drv_shutdown(struct device *_dev)
|
|||
struct platform_driver *drv = to_platform_driver(_dev->driver);
|
||||
struct platform_device *dev = to_platform_device(_dev);
|
||||
|
||||
drv->shutdown(dev);
|
||||
if (drv->shutdown)
|
||||
drv->shutdown(dev);
|
||||
dev_pm_domain_detach(_dev, true);
|
||||
}
|
||||
|
||||
|
|
@ -563,12 +565,9 @@ int __platform_driver_register(struct platform_driver *drv,
|
|||
{
|
||||
drv->driver.owner = owner;
|
||||
drv->driver.bus = &platform_bus_type;
|
||||
if (drv->probe)
|
||||
drv->driver.probe = platform_drv_probe;
|
||||
if (drv->remove)
|
||||
drv->driver.remove = platform_drv_remove;
|
||||
if (drv->shutdown)
|
||||
drv->driver.shutdown = platform_drv_shutdown;
|
||||
drv->driver.probe = platform_drv_probe;
|
||||
drv->driver.remove = platform_drv_remove;
|
||||
drv->driver.shutdown = platform_drv_shutdown;
|
||||
|
||||
return driver_register(&drv->driver);
|
||||
}
|
||||
|
|
@ -711,6 +710,67 @@ err_out:
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(__platform_create_bundle);
|
||||
|
||||
/**
|
||||
* __platform_register_drivers - register an array of platform drivers
|
||||
* @drivers: an array of drivers to register
|
||||
* @count: the number of drivers to register
|
||||
* @owner: module owning the drivers
|
||||
*
|
||||
* Registers platform drivers specified by an array. On failure to register a
|
||||
* driver, all previously registered drivers will be unregistered. Callers of
|
||||
* this API should use platform_unregister_drivers() to unregister drivers in
|
||||
* the reverse order.
|
||||
*
|
||||
* Returns: 0 on success or a negative error code on failure.
|
||||
*/
|
||||
int __platform_register_drivers(struct platform_driver * const *drivers,
|
||||
unsigned int count, struct module *owner)
|
||||
{
|
||||
unsigned int i;
|
||||
int err;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
pr_debug("registering platform driver %ps\n", drivers[i]);
|
||||
|
||||
err = __platform_driver_register(drivers[i], owner);
|
||||
if (err < 0) {
|
||||
pr_err("failed to register platform driver %ps: %d\n",
|
||||
drivers[i], err);
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
while (i--) {
|
||||
pr_debug("unregistering platform driver %ps\n", drivers[i]);
|
||||
platform_driver_unregister(drivers[i]);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(__platform_register_drivers);
|
||||
|
||||
/**
|
||||
* platform_unregister_drivers - unregister an array of platform drivers
|
||||
* @drivers: an array of drivers to unregister
|
||||
* @count: the number of drivers to unregister
|
||||
*
|
||||
* Unegisters platform drivers specified by an array. This is typically used
|
||||
* to complement an earlier call to platform_register_drivers(). Drivers are
|
||||
* unregistered in the reverse order in which they were registered.
|
||||
*/
|
||||
void platform_unregister_drivers(struct platform_driver * const *drivers,
|
||||
unsigned int count)
|
||||
{
|
||||
while (count--) {
|
||||
pr_debug("unregistering platform driver %ps\n", drivers[count]);
|
||||
platform_driver_unregister(drivers[count]);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(platform_unregister_drivers);
|
||||
|
||||
/* modalias support enables more hands-off userspace setup:
|
||||
* (a) environment variable lets new-style hotplug events work once system is
|
||||
* fully running: "modprobe $MODALIAS"
|
||||
|
|
|
|||
|
|
@ -125,9 +125,9 @@ struct regmap {
|
|||
unsigned int num_reg_defaults_raw;
|
||||
|
||||
/* if set, only the cache is modified not the HW */
|
||||
u32 cache_only;
|
||||
bool cache_only;
|
||||
/* if set, only the HW is modified not the cache */
|
||||
u32 cache_bypass;
|
||||
bool cache_bypass;
|
||||
/* if set, remember to free reg_defaults_raw */
|
||||
bool cache_free;
|
||||
|
||||
|
|
@ -135,7 +135,7 @@ struct regmap {
|
|||
const void *reg_defaults_raw;
|
||||
void *cache;
|
||||
/* if set, the cache contains newer data than the HW */
|
||||
u32 cache_dirty;
|
||||
bool cache_dirty;
|
||||
/* if set, the HW registers are known to match map->reg_defaults */
|
||||
bool no_sync_defaults;
|
||||
|
||||
|
|
|
|||
|
|
@ -355,9 +355,9 @@ static int regcache_lzo_sync(struct regmap *map, unsigned int min,
|
|||
if (ret > 0 && val == map->reg_defaults[ret].def)
|
||||
continue;
|
||||
|
||||
map->cache_bypass = 1;
|
||||
map->cache_bypass = true;
|
||||
ret = _regmap_write(map, i, val);
|
||||
map->cache_bypass = 0;
|
||||
map->cache_bypass = false;
|
||||
if (ret)
|
||||
return ret;
|
||||
dev_dbg(map->dev, "Synced register %#x, value %#x\n",
|
||||
|
|
|
|||
|
|
@ -54,11 +54,11 @@ static int regcache_hw_init(struct regmap *map)
|
|||
return -ENOMEM;
|
||||
|
||||
if (!map->reg_defaults_raw) {
|
||||
u32 cache_bypass = map->cache_bypass;
|
||||
bool cache_bypass = map->cache_bypass;
|
||||
dev_warn(map->dev, "No cache defaults, reading back from HW\n");
|
||||
|
||||
/* Bypass the cache access till data read from HW*/
|
||||
map->cache_bypass = 1;
|
||||
map->cache_bypass = true;
|
||||
tmp_buf = kmalloc(map->cache_size_raw, GFP_KERNEL);
|
||||
if (!tmp_buf) {
|
||||
ret = -ENOMEM;
|
||||
|
|
@ -285,9 +285,9 @@ static int regcache_default_sync(struct regmap *map, unsigned int min,
|
|||
if (!regcache_reg_needs_sync(map, reg, val))
|
||||
continue;
|
||||
|
||||
map->cache_bypass = 1;
|
||||
map->cache_bypass = true;
|
||||
ret = _regmap_write(map, reg, val);
|
||||
map->cache_bypass = 0;
|
||||
map->cache_bypass = false;
|
||||
if (ret) {
|
||||
dev_err(map->dev, "Unable to sync register %#x. %d\n",
|
||||
reg, ret);
|
||||
|
|
@ -315,7 +315,7 @@ int regcache_sync(struct regmap *map)
|
|||
int ret = 0;
|
||||
unsigned int i;
|
||||
const char *name;
|
||||
unsigned int bypass;
|
||||
bool bypass;
|
||||
|
||||
BUG_ON(!map->cache_ops);
|
||||
|
||||
|
|
@ -333,7 +333,7 @@ int regcache_sync(struct regmap *map)
|
|||
map->async = true;
|
||||
|
||||
/* Apply any patch first */
|
||||
map->cache_bypass = 1;
|
||||
map->cache_bypass = true;
|
||||
for (i = 0; i < map->patch_regs; i++) {
|
||||
ret = _regmap_write(map, map->patch[i].reg, map->patch[i].def);
|
||||
if (ret != 0) {
|
||||
|
|
@ -342,7 +342,7 @@ int regcache_sync(struct regmap *map)
|
|||
goto out;
|
||||
}
|
||||
}
|
||||
map->cache_bypass = 0;
|
||||
map->cache_bypass = false;
|
||||
|
||||
if (map->cache_ops->sync)
|
||||
ret = map->cache_ops->sync(map, 0, map->max_register);
|
||||
|
|
@ -384,7 +384,7 @@ int regcache_sync_region(struct regmap *map, unsigned int min,
|
|||
{
|
||||
int ret = 0;
|
||||
const char *name;
|
||||
unsigned int bypass;
|
||||
bool bypass;
|
||||
|
||||
BUG_ON(!map->cache_ops);
|
||||
|
||||
|
|
@ -637,11 +637,11 @@ static int regcache_sync_block_single(struct regmap *map, void *block,
|
|||
if (!regcache_reg_needs_sync(map, regtmp, val))
|
||||
continue;
|
||||
|
||||
map->cache_bypass = 1;
|
||||
map->cache_bypass = true;
|
||||
|
||||
ret = _regmap_write(map, regtmp, val);
|
||||
|
||||
map->cache_bypass = 0;
|
||||
map->cache_bypass = false;
|
||||
if (ret != 0) {
|
||||
dev_err(map->dev, "Unable to sync register %#x. %d\n",
|
||||
regtmp, ret);
|
||||
|
|
@ -668,14 +668,14 @@ static int regcache_sync_block_raw_flush(struct regmap *map, const void **data,
|
|||
dev_dbg(map->dev, "Writing %zu bytes for %d registers from 0x%x-0x%x\n",
|
||||
count * val_bytes, count, base, cur - map->reg_stride);
|
||||
|
||||
map->cache_bypass = 1;
|
||||
map->cache_bypass = true;
|
||||
|
||||
ret = _regmap_raw_write(map, base, *data, count * val_bytes);
|
||||
if (ret)
|
||||
dev_err(map->dev, "Unable to sync registers %#x-%#x. %d\n",
|
||||
base, cur - map->reg_stride, ret);
|
||||
|
||||
map->cache_bypass = 0;
|
||||
map->cache_bypass = false;
|
||||
|
||||
*data = NULL;
|
||||
|
||||
|
|
|
|||
|
|
@ -16,7 +16,6 @@
|
|||
#include <linux/err.h>
|
||||
|
||||
static DEFINE_IDA(soc_ida);
|
||||
static DEFINE_SPINLOCK(soc_lock);
|
||||
|
||||
static ssize_t soc_info_get(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
|
|
@ -122,20 +121,10 @@ struct soc_device *soc_device_register(struct soc_device_attribute *soc_dev_attr
|
|||
}
|
||||
|
||||
/* Fetch a unique (reclaimable) SOC ID. */
|
||||
do {
|
||||
if (!ida_pre_get(&soc_ida, GFP_KERNEL)) {
|
||||
ret = -ENOMEM;
|
||||
goto out2;
|
||||
}
|
||||
|
||||
spin_lock(&soc_lock);
|
||||
ret = ida_get_new(&soc_ida, &soc_dev->soc_dev_num);
|
||||
spin_unlock(&soc_lock);
|
||||
|
||||
} while (ret == -EAGAIN);
|
||||
|
||||
if (ret)
|
||||
ret = ida_simple_get(&soc_ida, 0, 0, GFP_KERNEL);
|
||||
if (ret < 0)
|
||||
goto out2;
|
||||
soc_dev->soc_dev_num = ret;
|
||||
|
||||
soc_dev->attr = soc_dev_attr;
|
||||
soc_dev->dev.bus = &soc_bus_type;
|
||||
|
|
@ -151,7 +140,7 @@ struct soc_device *soc_device_register(struct soc_device_attribute *soc_dev_attr
|
|||
return soc_dev;
|
||||
|
||||
out3:
|
||||
ida_remove(&soc_ida, soc_dev->soc_dev_num);
|
||||
ida_simple_remove(&soc_ida, soc_dev->soc_dev_num);
|
||||
out2:
|
||||
kfree(soc_dev);
|
||||
out1:
|
||||
|
|
@ -161,7 +150,7 @@ out1:
|
|||
/* Ensure soc_dev->attr is freed prior to calling soc_device_unregister. */
|
||||
void soc_device_unregister(struct soc_device *soc_dev)
|
||||
{
|
||||
ida_remove(&soc_ida, soc_dev->soc_dev_num);
|
||||
ida_simple_remove(&soc_ida, soc_dev->soc_dev_num);
|
||||
|
||||
device_unregister(&soc_dev->dev);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -80,8 +80,8 @@ struct qca_data {
|
|||
spinlock_t hci_ibs_lock; /* HCI_IBS state lock */
|
||||
u8 tx_ibs_state; /* HCI_IBS transmit side power state*/
|
||||
u8 rx_ibs_state; /* HCI_IBS receive side power state */
|
||||
u32 tx_vote; /* Clock must be on for TX */
|
||||
u32 rx_vote; /* Clock must be on for RX */
|
||||
bool tx_vote; /* Clock must be on for TX */
|
||||
bool rx_vote; /* Clock must be on for RX */
|
||||
struct timer_list tx_idle_timer;
|
||||
u32 tx_idle_delay;
|
||||
struct timer_list wake_retrans_timer;
|
||||
|
|
|
|||
|
|
@ -138,7 +138,7 @@ u16 amd_iommu_last_bdf; /* largest PCI device id we have
|
|||
to handle */
|
||||
LIST_HEAD(amd_iommu_unity_map); /* a list of required unity mappings
|
||||
we find in ACPI */
|
||||
u32 amd_iommu_unmap_flush; /* if true, flush on every unmap */
|
||||
bool amd_iommu_unmap_flush; /* if true, flush on every unmap */
|
||||
|
||||
LIST_HEAD(amd_iommu_list); /* list of all AMD IOMMUs in the
|
||||
system */
|
||||
|
|
|
|||
|
|
@ -675,7 +675,7 @@ extern unsigned long *amd_iommu_pd_alloc_bitmap;
|
|||
* If true, the addresses will be flushed on unmap time, not when
|
||||
* they are reused
|
||||
*/
|
||||
extern u32 amd_iommu_unmap_flush;
|
||||
extern bool amd_iommu_unmap_flush;
|
||||
|
||||
/* Smallest max PASID supported by any IOMMU in the system */
|
||||
extern u32 amd_iommu_max_pasid;
|
||||
|
|
|
|||
|
|
@ -528,7 +528,7 @@ struct mei_device {
|
|||
DECLARE_BITMAP(host_clients_map, MEI_CLIENTS_MAX);
|
||||
unsigned long me_client_index;
|
||||
|
||||
u32 allow_fixed_address;
|
||||
bool allow_fixed_address;
|
||||
|
||||
struct mei_cl wd_cl;
|
||||
enum mei_wd_states wd_state;
|
||||
|
|
|
|||
|
|
@ -771,8 +771,8 @@ struct adapter {
|
|||
bool tid_release_task_busy;
|
||||
|
||||
struct dentry *debugfs_root;
|
||||
u32 use_bd; /* Use SGE Back Door intfc for reading SGE Contexts */
|
||||
u32 trace_rss; /* 1 implies that different RSS flit per filter is
|
||||
bool use_bd; /* Use SGE Back Door intfc for reading SGE Contexts */
|
||||
bool trace_rss; /* 1 implies that different RSS flit per filter is
|
||||
* used per filter else if 0 default RSS flit is
|
||||
* used for all 4 filters.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -738,7 +738,7 @@ struct ath10k {
|
|||
bool monitor_started;
|
||||
unsigned int filter_flags;
|
||||
unsigned long dev_flags;
|
||||
u32 dfs_block_radar_events;
|
||||
bool dfs_block_radar_events;
|
||||
|
||||
/* protected by conf_mutex */
|
||||
bool radar_enabled;
|
||||
|
|
|
|||
|
|
@ -1367,7 +1367,7 @@ struct ath5k_hw {
|
|||
u8 ah_retry_long;
|
||||
u8 ah_retry_short;
|
||||
|
||||
u32 ah_use_32khz_clock;
|
||||
bool ah_use_32khz_clock;
|
||||
|
||||
u8 ah_coverage_class;
|
||||
bool ah_ack_bitrate_high;
|
||||
|
|
|
|||
|
|
@ -385,7 +385,7 @@ static void ath9k_hw_init_config(struct ath_hw *ah)
|
|||
|
||||
ah->config.dma_beacon_response_time = 1;
|
||||
ah->config.sw_beacon_response_time = 6;
|
||||
ah->config.cwm_ignore_extcca = 0;
|
||||
ah->config.cwm_ignore_extcca = false;
|
||||
ah->config.analog_shiftreg = 1;
|
||||
|
||||
ah->config.rx_intr_mitigation = true;
|
||||
|
|
|
|||
|
|
@ -332,14 +332,14 @@ enum ath9k_hw_hang_checks {
|
|||
struct ath9k_ops_config {
|
||||
int dma_beacon_response_time;
|
||||
int sw_beacon_response_time;
|
||||
u32 cwm_ignore_extcca;
|
||||
bool cwm_ignore_extcca;
|
||||
u32 pcie_waen;
|
||||
u8 analog_shiftreg;
|
||||
u32 ofdm_trig_low;
|
||||
u32 ofdm_trig_high;
|
||||
u32 cck_trig_high;
|
||||
u32 cck_trig_low;
|
||||
u32 enable_paprd;
|
||||
bool enable_paprd;
|
||||
int serialize_regmode;
|
||||
bool rx_intr_mitigation;
|
||||
bool tx_intr_mitigation;
|
||||
|
|
|
|||
|
|
@ -676,15 +676,15 @@ static void b43_add_dynamic_debug(struct b43_wldev *dev)
|
|||
e->dyn_debug_dentries[id] = d; \
|
||||
} while (0)
|
||||
|
||||
add_dyn_dbg("debug_xmitpower", B43_DBG_XMITPOWER, 0);
|
||||
add_dyn_dbg("debug_dmaoverflow", B43_DBG_DMAOVERFLOW, 0);
|
||||
add_dyn_dbg("debug_dmaverbose", B43_DBG_DMAVERBOSE, 0);
|
||||
add_dyn_dbg("debug_pwork_fast", B43_DBG_PWORK_FAST, 0);
|
||||
add_dyn_dbg("debug_pwork_stop", B43_DBG_PWORK_STOP, 0);
|
||||
add_dyn_dbg("debug_lo", B43_DBG_LO, 0);
|
||||
add_dyn_dbg("debug_firmware", B43_DBG_FIRMWARE, 0);
|
||||
add_dyn_dbg("debug_keys", B43_DBG_KEYS, 0);
|
||||
add_dyn_dbg("debug_verbose_stats", B43_DBG_VERBOSESTATS, 0);
|
||||
add_dyn_dbg("debug_xmitpower", B43_DBG_XMITPOWER, false);
|
||||
add_dyn_dbg("debug_dmaoverflow", B43_DBG_DMAOVERFLOW, false);
|
||||
add_dyn_dbg("debug_dmaverbose", B43_DBG_DMAVERBOSE, false);
|
||||
add_dyn_dbg("debug_pwork_fast", B43_DBG_PWORK_FAST, false);
|
||||
add_dyn_dbg("debug_pwork_stop", B43_DBG_PWORK_STOP, false);
|
||||
add_dyn_dbg("debug_lo", B43_DBG_LO, false);
|
||||
add_dyn_dbg("debug_firmware", B43_DBG_FIRMWARE, false);
|
||||
add_dyn_dbg("debug_keys", B43_DBG_KEYS, false);
|
||||
add_dyn_dbg("debug_verbose_stats", B43_DBG_VERBOSESTATS, false);
|
||||
|
||||
#undef add_dyn_dbg
|
||||
}
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ struct b43_dfsentry {
|
|||
u32 shm32read_addr_next;
|
||||
|
||||
/* Enabled/Disabled list for the dynamic debugging features. */
|
||||
u32 dyn_debug[__B43_NR_DYNDBG];
|
||||
bool dyn_debug[__B43_NR_DYNDBG];
|
||||
/* Dentries for the dynamic debugging entries. */
|
||||
struct dentry *dyn_debug_dentries[__B43_NR_DYNDBG];
|
||||
};
|
||||
|
|
|
|||
|
|
@ -369,11 +369,11 @@ static void b43legacy_add_dynamic_debug(struct b43legacy_wldev *dev)
|
|||
e->dyn_debug_dentries[id] = d; \
|
||||
} while (0)
|
||||
|
||||
add_dyn_dbg("debug_xmitpower", B43legacy_DBG_XMITPOWER, 0);
|
||||
add_dyn_dbg("debug_dmaoverflow", B43legacy_DBG_DMAOVERFLOW, 0);
|
||||
add_dyn_dbg("debug_dmaverbose", B43legacy_DBG_DMAVERBOSE, 0);
|
||||
add_dyn_dbg("debug_pwork_fast", B43legacy_DBG_PWORK_FAST, 0);
|
||||
add_dyn_dbg("debug_pwork_stop", B43legacy_DBG_PWORK_STOP, 0);
|
||||
add_dyn_dbg("debug_xmitpower", B43legacy_DBG_XMITPOWER, false);
|
||||
add_dyn_dbg("debug_dmaoverflow", B43legacy_DBG_DMAOVERFLOW, false);
|
||||
add_dyn_dbg("debug_dmaverbose", B43legacy_DBG_DMAVERBOSE, false);
|
||||
add_dyn_dbg("debug_pwork_fast", B43legacy_DBG_PWORK_FAST, false);
|
||||
add_dyn_dbg("debug_pwork_stop", B43legacy_DBG_PWORK_STOP, false);
|
||||
|
||||
#undef add_dyn_dbg
|
||||
}
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ struct b43legacy_dfsentry {
|
|||
struct b43legacy_txstatus_log txstatlog;
|
||||
|
||||
/* Enabled/Disabled list for the dynamic debugging features. */
|
||||
u32 dyn_debug[__B43legacy_NR_DYNDBG];
|
||||
bool dyn_debug[__B43legacy_NR_DYNDBG];
|
||||
/* Dentries for the dynamic debugging entries. */
|
||||
struct dentry *dyn_debug_dentries[__B43legacy_NR_DYNDBG];
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1425,9 +1425,9 @@ struct il_priv {
|
|||
#endif /* CONFIG_IWLEGACY_DEBUGFS */
|
||||
|
||||
struct work_struct txpower_work;
|
||||
u32 disable_sens_cal;
|
||||
u32 disable_chain_noise_cal;
|
||||
u32 disable_tx_power_cal;
|
||||
bool disable_sens_cal;
|
||||
bool disable_chain_noise_cal;
|
||||
bool disable_tx_power_cal;
|
||||
struct work_struct run_time_calib_work;
|
||||
struct timer_list stats_periodic;
|
||||
struct timer_list watchdog;
|
||||
|
|
|
|||
|
|
@ -658,7 +658,7 @@ struct iwl_mvm {
|
|||
const struct iwl_fw_bcast_filter *bcast_filters;
|
||||
#ifdef CONFIG_IWLWIFI_DEBUGFS
|
||||
struct {
|
||||
u32 override; /* u32 for debugfs_create_bool */
|
||||
bool override;
|
||||
struct iwl_bcast_filter_cmd cmd;
|
||||
} dbgfs_bcast_filtering;
|
||||
#endif
|
||||
|
|
@ -682,7 +682,7 @@ struct iwl_mvm {
|
|||
bool disable_power_off;
|
||||
bool disable_power_off_d3;
|
||||
|
||||
u32 scan_iter_notif_enabled; /* must be u32 for debugfs_create_bool */
|
||||
bool scan_iter_notif_enabled;
|
||||
|
||||
struct debugfs_blob_wrapper nvm_hw_blob;
|
||||
struct debugfs_blob_wrapper nvm_sw_blob;
|
||||
|
|
@ -739,7 +739,7 @@ struct iwl_mvm {
|
|||
int n_nd_channels;
|
||||
bool net_detect;
|
||||
#ifdef CONFIG_IWLWIFI_DEBUGFS
|
||||
u32 d3_wake_sysassert; /* must be u32 for debugfs_create_bool */
|
||||
bool d3_wake_sysassert;
|
||||
bool d3_test_active;
|
||||
bool store_d3_resume_sram;
|
||||
void *d3_resume_sram;
|
||||
|
|
|
|||
|
|
@ -60,11 +60,12 @@ int of_device_add(struct platform_device *ofdev)
|
|||
ofdev->name = dev_name(&ofdev->dev);
|
||||
ofdev->id = -1;
|
||||
|
||||
/* device_add will assume that this device is on the same node as
|
||||
* the parent. If there is no parent defined, set the node
|
||||
* explicitly */
|
||||
if (!ofdev->dev.parent)
|
||||
set_dev_node(&ofdev->dev, of_node_to_nid(ofdev->dev.of_node));
|
||||
/*
|
||||
* If this device has not binding numa node in devicetree, that is
|
||||
* of_node_to_nid returns NUMA_NO_NODE. device_add will assume that this
|
||||
* device is on the same node as the parent.
|
||||
*/
|
||||
set_dev_node(&ofdev->dev, of_node_to_nid(ofdev->dev.of_node));
|
||||
|
||||
return device_add(&ofdev->dev);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -148,7 +148,7 @@ snic_trc_init(void)
|
|||
|
||||
trc->max_idx = (tbuf_sz / SNIC_TRC_ENTRY_SZ);
|
||||
trc->rd_idx = trc->wr_idx = 0;
|
||||
trc->enable = 1;
|
||||
trc->enable = true;
|
||||
SNIC_INFO("Trace Facility Enabled.\n Trace Buffer SZ %lu Pages.\n",
|
||||
tbuf_sz / PAGE_SIZE);
|
||||
ret = 0;
|
||||
|
|
@ -169,7 +169,7 @@ snic_trc_free(void)
|
|||
{
|
||||
struct snic_trc *trc = &snic_glob->trc;
|
||||
|
||||
trc->enable = 0;
|
||||
trc->enable = false;
|
||||
snic_trc_debugfs_term();
|
||||
|
||||
if (trc->buf) {
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ struct snic_trc {
|
|||
u32 max_idx; /* Max Index into trace buffer */
|
||||
u32 rd_idx;
|
||||
u32 wr_idx;
|
||||
u32 enable; /* Control Variable for Tracing */
|
||||
bool enable; /* Control Variable for Tracing */
|
||||
|
||||
struct dentry *trc_enable; /* debugfs file object */
|
||||
struct dentry *trc_file;
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@
|
|||
struct uwb_dbg {
|
||||
struct uwb_pal pal;
|
||||
|
||||
u32 accept;
|
||||
bool accept;
|
||||
struct list_head rsvs;
|
||||
|
||||
struct dentry *root_d;
|
||||
|
|
|
|||
|
|
@ -42,6 +42,22 @@ const struct file_operations debugfs_file_operations = {
|
|||
.llseek = noop_llseek,
|
||||
};
|
||||
|
||||
static struct dentry *debugfs_create_mode(const char *name, umode_t mode,
|
||||
struct dentry *parent, void *value,
|
||||
const struct file_operations *fops,
|
||||
const struct file_operations *fops_ro,
|
||||
const struct file_operations *fops_wo)
|
||||
{
|
||||
/* if there are no write bits set, make read only */
|
||||
if (!(mode & S_IWUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, fops_ro);
|
||||
/* if there are no read bits set, make write only */
|
||||
if (!(mode & S_IRUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, fops_wo);
|
||||
|
||||
return debugfs_create_file(name, mode, parent, value, fops);
|
||||
}
|
||||
|
||||
static int debugfs_u8_set(void *data, u64 val)
|
||||
{
|
||||
*(u8 *)data = val;
|
||||
|
|
@ -83,14 +99,8 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
|
|||
struct dentry *debugfs_create_u8(const char *name, umode_t mode,
|
||||
struct dentry *parent, u8 *value)
|
||||
{
|
||||
/* if there are no write bits set, make read only */
|
||||
if (!(mode & S_IWUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_u8_ro);
|
||||
/* if there are no read bits set, make write only */
|
||||
if (!(mode & S_IRUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_u8_wo);
|
||||
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_u8);
|
||||
return debugfs_create_mode(name, mode, parent, value, &fops_u8,
|
||||
&fops_u8_ro, &fops_u8_wo);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(debugfs_create_u8);
|
||||
|
||||
|
|
@ -135,14 +145,8 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
|
|||
struct dentry *debugfs_create_u16(const char *name, umode_t mode,
|
||||
struct dentry *parent, u16 *value)
|
||||
{
|
||||
/* if there are no write bits set, make read only */
|
||||
if (!(mode & S_IWUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_u16_ro);
|
||||
/* if there are no read bits set, make write only */
|
||||
if (!(mode & S_IRUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_u16_wo);
|
||||
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_u16);
|
||||
return debugfs_create_mode(name, mode, parent, value, &fops_u16,
|
||||
&fops_u16_ro, &fops_u16_wo);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(debugfs_create_u16);
|
||||
|
||||
|
|
@ -187,14 +191,8 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
|
|||
struct dentry *debugfs_create_u32(const char *name, umode_t mode,
|
||||
struct dentry *parent, u32 *value)
|
||||
{
|
||||
/* if there are no write bits set, make read only */
|
||||
if (!(mode & S_IWUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_u32_ro);
|
||||
/* if there are no read bits set, make write only */
|
||||
if (!(mode & S_IRUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_u32_wo);
|
||||
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_u32);
|
||||
return debugfs_create_mode(name, mode, parent, value, &fops_u32,
|
||||
&fops_u32_ro, &fops_u32_wo);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(debugfs_create_u32);
|
||||
|
||||
|
|
@ -240,17 +238,59 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
|
|||
struct dentry *debugfs_create_u64(const char *name, umode_t mode,
|
||||
struct dentry *parent, u64 *value)
|
||||
{
|
||||
/* if there are no write bits set, make read only */
|
||||
if (!(mode & S_IWUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_u64_ro);
|
||||
/* if there are no read bits set, make write only */
|
||||
if (!(mode & S_IRUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_u64_wo);
|
||||
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_u64);
|
||||
return debugfs_create_mode(name, mode, parent, value, &fops_u64,
|
||||
&fops_u64_ro, &fops_u64_wo);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(debugfs_create_u64);
|
||||
|
||||
static int debugfs_ulong_set(void *data, u64 val)
|
||||
{
|
||||
*(unsigned long *)data = val;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int debugfs_ulong_get(void *data, u64 *val)
|
||||
{
|
||||
*val = *(unsigned long *)data;
|
||||
return 0;
|
||||
}
|
||||
DEFINE_SIMPLE_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set, "%llu\n");
|
||||
DEFINE_SIMPLE_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");
|
||||
DEFINE_SIMPLE_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");
|
||||
|
||||
/**
|
||||
* debugfs_create_ulong - create a debugfs file that is used to read and write
|
||||
* an unsigned long value.
|
||||
* @name: a pointer to a string containing the name of the file to create.
|
||||
* @mode: the permission that the file should have
|
||||
* @parent: a pointer to the parent dentry for this file. This should be a
|
||||
* directory dentry if set. If this parameter is %NULL, then the
|
||||
* file will be created in the root of the debugfs filesystem.
|
||||
* @value: a pointer to the variable that the file should read to and write
|
||||
* from.
|
||||
*
|
||||
* This function creates a file in debugfs with the given name that
|
||||
* contains the value of the variable @value. If the @mode variable is so
|
||||
* set, it can be read from, and written to.
|
||||
*
|
||||
* This function will return a pointer to a dentry if it succeeds. This
|
||||
* pointer must be passed to the debugfs_remove() function when the file is
|
||||
* to be removed (no automatic cleanup happens if your module is unloaded,
|
||||
* you are responsible here.) If an error occurs, %NULL will be returned.
|
||||
*
|
||||
* If debugfs is not enabled in the kernel, the value -%ENODEV will be
|
||||
* returned. It is not wise to check for this value, but rather, check for
|
||||
* %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
|
||||
* code.
|
||||
*/
|
||||
struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
|
||||
struct dentry *parent, unsigned long *value)
|
||||
{
|
||||
return debugfs_create_mode(name, mode, parent, value, &fops_ulong,
|
||||
&fops_ulong_ro, &fops_ulong_wo);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(debugfs_create_ulong);
|
||||
|
||||
DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
|
||||
DEFINE_SIMPLE_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
|
||||
DEFINE_SIMPLE_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
|
||||
|
|
@ -264,6 +304,8 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
|
|||
DEFINE_SIMPLE_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
|
||||
|
||||
DEFINE_SIMPLE_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, "0x%016llx\n");
|
||||
DEFINE_SIMPLE_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");
|
||||
DEFINE_SIMPLE_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");
|
||||
|
||||
/*
|
||||
* debugfs_create_x{8,16,32,64} - create a debugfs file that is used to read and write an unsigned {8,16,32,64}-bit value
|
||||
|
|
@ -286,14 +328,8 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, "0x%016llx\n
|
|||
struct dentry *debugfs_create_x8(const char *name, umode_t mode,
|
||||
struct dentry *parent, u8 *value)
|
||||
{
|
||||
/* if there are no write bits set, make read only */
|
||||
if (!(mode & S_IWUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_x8_ro);
|
||||
/* if there are no read bits set, make write only */
|
||||
if (!(mode & S_IRUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_x8_wo);
|
||||
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_x8);
|
||||
return debugfs_create_mode(name, mode, parent, value, &fops_x8,
|
||||
&fops_x8_ro, &fops_x8_wo);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(debugfs_create_x8);
|
||||
|
||||
|
|
@ -310,14 +346,8 @@ EXPORT_SYMBOL_GPL(debugfs_create_x8);
|
|||
struct dentry *debugfs_create_x16(const char *name, umode_t mode,
|
||||
struct dentry *parent, u16 *value)
|
||||
{
|
||||
/* if there are no write bits set, make read only */
|
||||
if (!(mode & S_IWUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_x16_ro);
|
||||
/* if there are no read bits set, make write only */
|
||||
if (!(mode & S_IRUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_x16_wo);
|
||||
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_x16);
|
||||
return debugfs_create_mode(name, mode, parent, value, &fops_x16,
|
||||
&fops_x16_ro, &fops_x16_wo);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(debugfs_create_x16);
|
||||
|
||||
|
|
@ -334,14 +364,8 @@ EXPORT_SYMBOL_GPL(debugfs_create_x16);
|
|||
struct dentry *debugfs_create_x32(const char *name, umode_t mode,
|
||||
struct dentry *parent, u32 *value)
|
||||
{
|
||||
/* if there are no write bits set, make read only */
|
||||
if (!(mode & S_IWUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_x32_ro);
|
||||
/* if there are no read bits set, make write only */
|
||||
if (!(mode & S_IRUGO))
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_x32_wo);
|
||||
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_x32);
|
||||
return debugfs_create_mode(name, mode, parent, value, &fops_x32,
|
||||
&fops_x32_ro, &fops_x32_wo);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(debugfs_create_x32);
|
||||
|
||||
|
|
@ -358,7 +382,8 @@ EXPORT_SYMBOL_GPL(debugfs_create_x32);
|
|||
struct dentry *debugfs_create_x64(const char *name, umode_t mode,
|
||||
struct dentry *parent, u64 *value)
|
||||
{
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_x64);
|
||||
return debugfs_create_mode(name, mode, parent, value, &fops_x64,
|
||||
&fops_x64_ro, &fops_x64_wo);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(debugfs_create_x64);
|
||||
|
||||
|
|
@ -375,6 +400,8 @@ static int debugfs_size_t_get(void *data, u64 *val)
|
|||
}
|
||||
DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
|
||||
"%llu\n"); /* %llu and %zu are more or less the same */
|
||||
DEFINE_SIMPLE_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");
|
||||
DEFINE_SIMPLE_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");
|
||||
|
||||
/**
|
||||
* debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
|
||||
|
|
@ -389,7 +416,8 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
|
|||
struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
|
||||
struct dentry *parent, size_t *value)
|
||||
{
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_size_t);
|
||||
return debugfs_create_mode(name, mode, parent, value, &fops_size_t,
|
||||
&fops_size_t_ro, &fops_size_t_wo);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(debugfs_create_size_t);
|
||||
|
||||
|
|
@ -422,16 +450,8 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set, "%lld\n");
|
|||
struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
|
||||
struct dentry *parent, atomic_t *value)
|
||||
{
|
||||
/* if there are no write bits set, make read only */
|
||||
if (!(mode & S_IWUGO))
|
||||
return debugfs_create_file(name, mode, parent, value,
|
||||
&fops_atomic_t_ro);
|
||||
/* if there are no read bits set, make write only */
|
||||
if (!(mode & S_IRUGO))
|
||||
return debugfs_create_file(name, mode, parent, value,
|
||||
&fops_atomic_t_wo);
|
||||
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_atomic_t);
|
||||
return debugfs_create_mode(name, mode, parent, value, &fops_atomic_t,
|
||||
&fops_atomic_t_ro, &fops_atomic_t_wo);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
|
||||
|
||||
|
|
@ -439,7 +459,7 @@ ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
|
|||
size_t count, loff_t *ppos)
|
||||
{
|
||||
char buf[3];
|
||||
u32 *val = file->private_data;
|
||||
bool *val = file->private_data;
|
||||
|
||||
if (*val)
|
||||
buf[0] = 'Y';
|
||||
|
|
@ -457,7 +477,7 @@ ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
|
|||
char buf[32];
|
||||
size_t buf_size;
|
||||
bool bv;
|
||||
u32 *val = file->private_data;
|
||||
bool *val = file->private_data;
|
||||
|
||||
buf_size = min(count, (sizeof(buf)-1));
|
||||
if (copy_from_user(buf, user_buf, buf_size))
|
||||
|
|
@ -478,6 +498,18 @@ static const struct file_operations fops_bool = {
|
|||
.llseek = default_llseek,
|
||||
};
|
||||
|
||||
static const struct file_operations fops_bool_ro = {
|
||||
.read = debugfs_read_file_bool,
|
||||
.open = simple_open,
|
||||
.llseek = default_llseek,
|
||||
};
|
||||
|
||||
static const struct file_operations fops_bool_wo = {
|
||||
.write = debugfs_write_file_bool,
|
||||
.open = simple_open,
|
||||
.llseek = default_llseek,
|
||||
};
|
||||
|
||||
/**
|
||||
* debugfs_create_bool - create a debugfs file that is used to read and write a boolean value
|
||||
* @name: a pointer to a string containing the name of the file to create.
|
||||
|
|
@ -503,9 +535,10 @@ static const struct file_operations fops_bool = {
|
|||
* code.
|
||||
*/
|
||||
struct dentry *debugfs_create_bool(const char *name, umode_t mode,
|
||||
struct dentry *parent, u32 *value)
|
||||
struct dentry *parent, bool *value)
|
||||
{
|
||||
return debugfs_create_file(name, mode, parent, value, &fops_bool);
|
||||
return debugfs_create_mode(name, mode, parent, value, &fops_bool,
|
||||
&fops_bool_ro, &fops_bool_wo);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(debugfs_create_bool);
|
||||
|
||||
|
|
|
|||
|
|
@ -533,7 +533,8 @@ static int __debugfs_remove(struct dentry *dentry, struct dentry *parent)
|
|||
/**
|
||||
* debugfs_remove - removes a file or directory from the debugfs filesystem
|
||||
* @dentry: a pointer to a the dentry of the file or directory to be
|
||||
* removed.
|
||||
* removed. If this parameter is NULL or an error value, nothing
|
||||
* will be done.
|
||||
*
|
||||
* This function removes a file or directory in debugfs that was previously
|
||||
* created with a call to another debugfs function (like
|
||||
|
|
@ -565,7 +566,8 @@ EXPORT_SYMBOL_GPL(debugfs_remove);
|
|||
|
||||
/**
|
||||
* debugfs_remove_recursive - recursively removes a directory
|
||||
* @dentry: a pointer to a the dentry of the directory to be removed.
|
||||
* @dentry: a pointer to a the dentry of the directory to be removed. If this
|
||||
* parameter is NULL or an error value, nothing will be done.
|
||||
*
|
||||
* This function recursively removes a directory tree in debugfs that
|
||||
* was previously created with a call to another debugfs function
|
||||
|
|
|
|||
|
|
@ -108,6 +108,7 @@ static ssize_t sysfs_kf_read(struct kernfs_open_file *of, char *buf,
|
|||
{
|
||||
const struct sysfs_ops *ops = sysfs_file_ops(of->kn);
|
||||
struct kobject *kobj = of->kn->parent->priv;
|
||||
size_t len;
|
||||
|
||||
/*
|
||||
* If buf != of->prealloc_buf, we don't know how
|
||||
|
|
@ -115,7 +116,8 @@ static ssize_t sysfs_kf_read(struct kernfs_open_file *of, char *buf,
|
|||
*/
|
||||
if (pos || WARN_ON_ONCE(buf != of->prealloc_buf))
|
||||
return 0;
|
||||
return ops->show(kobj, of->kn->priv, buf);
|
||||
len = ops->show(kobj, of->kn->priv, buf);
|
||||
return min(count, len);
|
||||
}
|
||||
|
||||
/* kernfs write callback for regular sysfs files */
|
||||
|
|
|
|||
|
|
@ -79,6 +79,8 @@ struct dentry *debugfs_create_u32(const char *name, umode_t mode,
|
|||
struct dentry *parent, u32 *value);
|
||||
struct dentry *debugfs_create_u64(const char *name, umode_t mode,
|
||||
struct dentry *parent, u64 *value);
|
||||
struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
|
||||
struct dentry *parent, unsigned long *value);
|
||||
struct dentry *debugfs_create_x8(const char *name, umode_t mode,
|
||||
struct dentry *parent, u8 *value);
|
||||
struct dentry *debugfs_create_x16(const char *name, umode_t mode,
|
||||
|
|
@ -92,7 +94,7 @@ struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
|
|||
struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
|
||||
struct dentry *parent, atomic_t *value);
|
||||
struct dentry *debugfs_create_bool(const char *name, umode_t mode,
|
||||
struct dentry *parent, u32 *value);
|
||||
struct dentry *parent, bool *value);
|
||||
|
||||
struct dentry *debugfs_create_blob(const char *name, umode_t mode,
|
||||
struct dentry *parent,
|
||||
|
|
@ -243,7 +245,7 @@ static inline struct dentry *debugfs_create_atomic_t(const char *name, umode_t m
|
|||
|
||||
static inline struct dentry *debugfs_create_bool(const char *name, umode_t mode,
|
||||
struct dentry *parent,
|
||||
u32 *value)
|
||||
bool *value)
|
||||
{
|
||||
return ERR_PTR(-ENODEV);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -771,7 +771,7 @@ struct mem_ctl_info {
|
|||
|
||||
struct dentry *debugfs;
|
||||
u8 fake_inject_layer[EDAC_MAX_LAYERS];
|
||||
u32 fake_inject_ue;
|
||||
bool fake_inject_ue;
|
||||
u16 fake_inject_count;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ struct fault_attr {
|
|||
atomic_t times;
|
||||
atomic_t space;
|
||||
unsigned long verbose;
|
||||
u32 task_filter;
|
||||
bool task_filter;
|
||||
unsigned long stacktrace_depth;
|
||||
unsigned long require_start;
|
||||
unsigned long require_end;
|
||||
|
|
|
|||
|
|
@ -66,7 +66,7 @@ struct kobject {
|
|||
struct kobject *parent;
|
||||
struct kset *kset;
|
||||
struct kobj_type *ktype;
|
||||
struct kernfs_node *sd;
|
||||
struct kernfs_node *sd; /* sysfs directory entry */
|
||||
struct kref kref;
|
||||
#ifdef CONFIG_DEBUG_KOBJECT_RELEASE
|
||||
struct delayed_work release;
|
||||
|
|
|
|||
|
|
@ -270,6 +270,14 @@ extern struct platform_device *__platform_create_bundle(
|
|||
struct resource *res, unsigned int n_res,
|
||||
const void *data, size_t size, struct module *module);
|
||||
|
||||
int __platform_register_drivers(struct platform_driver * const *drivers,
|
||||
unsigned int count, struct module *owner);
|
||||
void platform_unregister_drivers(struct platform_driver * const *drivers,
|
||||
unsigned int count);
|
||||
|
||||
#define platform_register_drivers(drivers, count) \
|
||||
__platform_register_drivers(drivers, count, THIS_MODULE)
|
||||
|
||||
/* early platform driver interface */
|
||||
struct early_platform_driver {
|
||||
const char *class_str;
|
||||
|
|
|
|||
|
|
@ -276,10 +276,10 @@ static struct {
|
|||
static struct {
|
||||
struct fault_attr attr;
|
||||
|
||||
u32 ignore_private;
|
||||
bool ignore_private;
|
||||
} fail_futex = {
|
||||
.attr = FAULT_ATTR_INITIALIZER,
|
||||
.ignore_private = 0,
|
||||
.ignore_private = false,
|
||||
};
|
||||
|
||||
static int __init setup_fail_futex(char *str)
|
||||
|
|
|
|||
|
|
@ -418,7 +418,7 @@ void pcim_iounmap_regions(struct pci_dev *pdev, int mask)
|
|||
if (!iomap)
|
||||
return;
|
||||
|
||||
for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
|
||||
for (i = 0; i < PCIM_IOMAP_MAX; i++) {
|
||||
if (!(mask & (1 << i)))
|
||||
continue;
|
||||
|
||||
|
|
|
|||
|
|
@ -100,7 +100,7 @@ static LIST_HEAD(free_entries);
|
|||
static DEFINE_SPINLOCK(free_entries_lock);
|
||||
|
||||
/* Global disable flag - will be set in case of an error */
|
||||
static u32 global_disable __read_mostly;
|
||||
static bool global_disable __read_mostly;
|
||||
|
||||
/* Early initialization disable flag, set at the end of dma_debug_init */
|
||||
static bool dma_debug_initialized __read_mostly;
|
||||
|
|
|
|||
|
|
@ -568,6 +568,7 @@ void kobject_del(struct kobject *kobj)
|
|||
kobject_put(kobj->parent);
|
||||
kobj->parent = NULL;
|
||||
}
|
||||
EXPORT_SYMBOL(kobject_del);
|
||||
|
||||
/**
|
||||
* kobject_get - increment refcount for object.
|
||||
|
|
@ -584,6 +585,7 @@ struct kobject *kobject_get(struct kobject *kobj)
|
|||
}
|
||||
return kobj;
|
||||
}
|
||||
EXPORT_SYMBOL(kobject_get);
|
||||
|
||||
static struct kobject * __must_check kobject_get_unless_zero(struct kobject *kobj)
|
||||
{
|
||||
|
|
@ -675,6 +677,7 @@ void kobject_put(struct kobject *kobj)
|
|||
kref_put(&kobj->kref, kobject_release);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(kobject_put);
|
||||
|
||||
static void dynamic_kobj_release(struct kobject *kobj)
|
||||
{
|
||||
|
|
@ -803,6 +806,7 @@ int kset_register(struct kset *k)
|
|||
kobject_uevent(&k->kobj, KOBJ_ADD);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(kset_register);
|
||||
|
||||
/**
|
||||
* kset_unregister - remove a kset.
|
||||
|
|
@ -815,6 +819,7 @@ void kset_unregister(struct kset *k)
|
|||
kobject_del(&k->kobj);
|
||||
kobject_put(&k->kobj);
|
||||
}
|
||||
EXPORT_SYMBOL(kset_unregister);
|
||||
|
||||
/**
|
||||
* kset_find_obj - search for object in kset.
|
||||
|
|
@ -1051,10 +1056,3 @@ void kobj_ns_drop(enum kobj_ns_type type, void *ns)
|
|||
kobj_ns_ops_tbl[type]->drop_ns(ns);
|
||||
spin_unlock(&kobj_ns_type_lock);
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL(kobject_get);
|
||||
EXPORT_SYMBOL(kobject_put);
|
||||
EXPORT_SYMBOL(kobject_del);
|
||||
|
||||
EXPORT_SYMBOL(kset_register);
|
||||
EXPORT_SYMBOL(kset_unregister);
|
||||
|
|
|
|||
|
|
@ -3,12 +3,12 @@
|
|||
|
||||
static struct {
|
||||
struct fault_attr attr;
|
||||
u32 ignore_gfp_wait;
|
||||
int cache_filter;
|
||||
bool ignore_gfp_wait;
|
||||
bool cache_filter;
|
||||
} failslab = {
|
||||
.attr = FAULT_ATTR_INITIALIZER,
|
||||
.ignore_gfp_wait = 1,
|
||||
.cache_filter = 0,
|
||||
.ignore_gfp_wait = true,
|
||||
.cache_filter = false,
|
||||
};
|
||||
|
||||
bool should_failslab(size_t size, gfp_t gfpflags, unsigned long cache_flags)
|
||||
|
|
|
|||
|
|
@ -2159,13 +2159,13 @@ failed:
|
|||
static struct {
|
||||
struct fault_attr attr;
|
||||
|
||||
u32 ignore_gfp_highmem;
|
||||
u32 ignore_gfp_wait;
|
||||
bool ignore_gfp_highmem;
|
||||
bool ignore_gfp_wait;
|
||||
u32 min_order;
|
||||
} fail_page_alloc = {
|
||||
.attr = FAULT_ATTR_INITIALIZER,
|
||||
.ignore_gfp_wait = 1,
|
||||
.ignore_gfp_highmem = 1,
|
||||
.ignore_gfp_wait = true,
|
||||
.ignore_gfp_highmem = true,
|
||||
.min_order = 1,
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ struct wm_adsp {
|
|||
|
||||
int fw;
|
||||
int fw_ver;
|
||||
u32 running;
|
||||
bool running;
|
||||
|
||||
struct list_head ctl_list;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue