#include <acpi/battery.h>
#define ACPI_AC_CLASS "ac_adapter"
-#define ACPI_AC_DEVICE_NAME "AC Adapter"
#define ACPI_AC_FILE_STATE "state"
#define ACPI_AC_NOTIFY_STATUS 0x80
#define ACPI_AC_STATUS_OFFLINE 0x00
return -ENOMEM;
ac->device = adev;
- strscpy(acpi_device_name(adev), ACPI_AC_DEVICE_NAME);
strscpy(acpi_device_class(adev), ACPI_AC_CLASS);
platform_set_drvdata(pdev, ac);
goto err_release_ac;
}
- pr_info("%s [%s] (%s-line)\n", acpi_device_name(adev),
- acpi_device_bid(adev), str_on_off(ac->state));
+ pr_info("AC Adapter [%s] (%s-line)\n", acpi_device_bid(adev),
+ str_on_off(ac->state));
ac->battery_nb.notifier_call = acpi_ac_battery_notify;
register_acpi_notifier(&ac->battery_nb);
#define ACPI_MEMORY_DEVICE_CLASS "memory"
#define ACPI_MEMORY_DEVICE_HID "PNP0C80"
-#define ACPI_MEMORY_DEVICE_NAME "Hotplug Mem Device"
static const struct acpi_device_id memory_device_ids[] = {
{ACPI_MEMORY_DEVICE_HID, 0},
INIT_LIST_HEAD(&mem_device->res_list);
mem_device->device = device;
mem_device->mgid = -1;
- sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME);
sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS);
device->driver_data = mem_device;
#include <xen/xen.h>
#define ACPI_PROCESSOR_AGGREGATOR_CLASS "acpi_pad"
-#define ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME "Processor Aggregator"
#define ACPI_PROCESSOR_AGGREGATOR_NOTIFY 0x80
#define ACPI_PROCESSOR_AGGREGATOR_STATUS_SUCCESS 0
{
struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
- strscpy(acpi_device_name(adev), ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME);
strscpy(acpi_device_class(adev), ACPI_PROCESSOR_AGGREGATOR_CLASS);
return acpi_dev_install_notify_handler(adev, ACPI_DEVICE_NOTIFY,
}
pr->handle = device->handle;
- strscpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
strscpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
device->driver_data = pr;
#include <linux/uaccess.h>
#include <linux/string_choices.h>
-#define ACPI_VIDEO_BUS_NAME "Video Bus"
-#define ACPI_VIDEO_DEVICE_NAME "Video Device"
-
#define MAX_NAME_LEN 20
MODULE_AUTHOR("Bruno Ducrot");
return -ENOMEM;
}
- strscpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
strscpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
data->device_id = device_id;
snprintf(video->phys, sizeof(video->phys),
"%s/video/input0", acpi_device_hid(video->device));
- input->name = acpi_device_name(video->device);
+ input->name = "Video Bus";
input->phys = video->phys;
input->id.bustype = BUS_HOST;
input->id.product = 0x06;
auxiliary_set_drvdata(aux_dev, video);
video->device = device;
- strscpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
strscpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
device->driver_data = video;
*/
acpi_device_fix_up_power_children(device);
- pr_info("%s [%s] (multi-head: %s rom: %s post: %s)\n",
- ACPI_VIDEO_DEVICE_NAME, acpi_device_bid(device),
- str_yes_no(video->flags.multihead),
- str_yes_no(video->flags.rom),
- str_yes_no(video->flags.post));
+ pr_info("Video Device [%s] (multi-head: %s rom: %s post: %s)\n",
+ acpi_device_bid(device), str_yes_no(video->flags.multihead),
+ str_yes_no(video->flags.rom), str_yes_no(video->flags.post));
+
mutex_lock(&video_list_lock);
list_add_tail(&video->entry, &video_bus_head);
mutex_unlock(&video_list_lock);
#define ACPI_BATTERY_CAPACITY_VALID(capacity) \
((capacity) != 0 && (capacity) != ACPI_BATTERY_VALUE_UNKNOWN)
-#define ACPI_BATTERY_DEVICE_NAME "Battery"
-
/* Battery power unit: 0 means mW, 1 means mA */
#define ACPI_BATTERY_POWER_UNIT_MA 1
platform_set_drvdata(pdev, battery);
battery->device = device;
- strscpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
strscpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
result = devm_mutex_init(&pdev->dev, &battery->update_lock);
goto err_free_button;
}
- name = acpi_device_name(device);
class = acpi_device_class(device);
if (!strcmp(hid, ACPI_BUTTON_HID_POWER) ||
!strcmp(hid, ACPI_BUTTON_HID_POWERF)) {
button->type = ACPI_BUTTON_TYPE_POWER;
handler = acpi_button_notify;
- strscpy(name, ACPI_BUTTON_DEVICE_NAME_POWER, MAX_ACPI_DEVICE_NAME_LEN);
+ name = ACPI_BUTTON_DEVICE_NAME_POWER;
sprintf(class, "%s/%s",
ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
} else if (!strcmp(hid, ACPI_BUTTON_HID_SLEEP) ||
!strcmp(hid, ACPI_BUTTON_HID_SLEEPF)) {
button->type = ACPI_BUTTON_TYPE_SLEEP;
handler = acpi_button_notify;
- strscpy(name, ACPI_BUTTON_DEVICE_NAME_SLEEP, MAX_ACPI_DEVICE_NAME_LEN);
+ name = ACPI_BUTTON_DEVICE_NAME_SLEEP;
sprintf(class, "%s/%s",
ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
} else if (!strcmp(hid, ACPI_BUTTON_HID_LID)) {
button->type = ACPI_BUTTON_TYPE_LID;
handler = acpi_lid_notify;
- strscpy(name, ACPI_BUTTON_DEVICE_NAME_LID, MAX_ACPI_DEVICE_NAME_LEN);
+ name = ACPI_BUTTON_DEVICE_NAME_LID;
sprintf(class, "%s/%s",
ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
input->open = acpi_lid_input_open;
#include "internal.h"
#define ACPI_EC_CLASS "embedded_controller"
-#define ACPI_EC_DEVICE_NAME "Embedded Controller"
/* EC status register */
#define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
struct acpi_ec *ec;
int ret;
- strscpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
strscpy(acpi_device_class(device), ACPI_EC_CLASS);
if (boot_ec && (boot_ec->handle == device->handle ||
#include "internal.h"
#define ACPI_PCI_LINK_CLASS "pci_irq_routing"
-#define ACPI_PCI_LINK_DEVICE_NAME "PCI Interrupt Link"
#define ACPI_PCI_LINK_MAX_POSSIBLE 16
static int acpi_pci_link_add(struct acpi_device *device,
return -ENOMEM;
link->device = device;
- strscpy(acpi_device_name(device), ACPI_PCI_LINK_DEVICE_NAME);
strscpy(acpi_device_class(device), ACPI_PCI_LINK_CLASS);
device->driver_data = link;
#include "internal.h"
#define ACPI_PCI_ROOT_CLASS "pci_bridge"
-#define ACPI_PCI_ROOT_DEVICE_NAME "PCI Root Bridge"
static int acpi_pci_root_add(struct acpi_device *device,
const struct acpi_device_id *not_used);
static void acpi_pci_root_remove(struct acpi_device *device);
root->device = device;
root->segment = segment & 0xFFFF;
- strscpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);
strscpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
device->driver_data = root;
goto end;
}
- pr_info("%s [%s] (domain %04x %pR)\n",
- acpi_device_name(device), acpi_device_bid(device),
- root->segment, &root->secondary);
+ pr_info("PCI Root Bridge [%s] (domain %04x %pR)\n",
+ acpi_device_bid(device), root->segment, &root->secondary);
root->mcfg_addr = acpi_pci_root_get_mcfg_addr(handle);
#include "internal.h"
#define ACPI_POWER_CLASS "power_resource"
-#define ACPI_POWER_DEVICE_NAME "Power Resource"
#define ACPI_POWER_RESOURCE_STATE_OFF 0x00
#define ACPI_POWER_RESOURCE_STATE_ON 0x01
#define ACPI_POWER_RESOURCE_STATE_UNKNOWN 0xFF
mutex_init(&resource->resource_lock);
INIT_LIST_HEAD(&resource->list_node);
INIT_LIST_HEAD(&resource->dependents);
- strscpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME);
strscpy(acpi_device_class(device), ACPI_POWER_CLASS);
device->power.state = ACPI_STATE_UNKNOWN;
device->flags.match_driver = true;
sbs->hc = dev_get_drvdata(pdev->dev.parent);
sbs->device = device;
- strscpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME);
strscpy(acpi_device_class(device), ACPI_SBS_CLASS);
result = acpi_charger_add(sbs);
#include "internal.h"
#define ACPI_SMB_HC_CLASS "smbus_host_ctl"
-#define ACPI_SMB_HC_DEVICE_NAME "ACPI SMBus HC"
struct acpi_smb_hc {
struct acpi_ec *ec;
return -EIO;
}
- strscpy(acpi_device_name(device), ACPI_SMB_HC_DEVICE_NAME);
strscpy(acpi_device_class(device), ACPI_SMB_HC_CLASS);
hc = kzalloc_obj(struct acpi_smb_hc);
#include "internal.h"
#define ACPI_THERMAL_CLASS "thermal_zone"
-#define ACPI_THERMAL_DEVICE_NAME "Thermal Zone"
#define ACPI_THERMAL_NOTIFY_TEMPERATURE 0x80
#define ACPI_THERMAL_NOTIFY_THRESHOLDS 0x81
#define ACPI_THERMAL_NOTIFY_DEVICES 0x82
tz->device = device;
strscpy(tz->name, device->pnp.bus_id);
- strscpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
strscpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
acpi_thermal_aml_dependency_fix(tz);
mutex_init(&tz->thermal_check_lock);
INIT_WORK(&tz->thermal_check_work, acpi_thermal_check_fn);
- pr_info("%s [%s] (%ld C)\n", acpi_device_name(device),
- acpi_device_bid(device), deci_kelvin_to_celsius(tz->temp_dk));
+ pr_info("Thermal Zone [%s] (%ld C)\n", acpi_device_bid(device),
+ deci_kelvin_to_celsius(tz->temp_dk));
result = acpi_dev_install_notify_handler(device, ACPI_DEVICE_NOTIFY,
acpi_thermal_notify, tz);
#include <asm/acpi.h>
#define ACPI_PROCESSOR_CLASS "processor"
-#define ACPI_PROCESSOR_DEVICE_NAME "Processor"
#define ACPI_PROCESSOR_DEVICE_HID "ACPI0007"
#define ACPI_PROCESSOR_CONTAINER_HID "ACPI0010"