mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
658 lines
17 KiB
658 lines
17 KiB
// SPDX-License-Identifier: GPL-2.0+ |
|
/* |
|
* Surface System Aggregator Module (SSAM) client device registry. |
|
* |
|
* Registry for non-platform/non-ACPI SSAM client devices, i.e. devices that |
|
* cannot be auto-detected. Provides device-hubs and performs instantiation |
|
* for these devices. |
|
* |
|
* Copyright (C) 2020-2021 Maximilian Luz <[email protected]> |
|
*/ |
|
|
|
#include <linux/acpi.h> |
|
#include <linux/kernel.h> |
|
#include <linux/limits.h> |
|
#include <linux/module.h> |
|
#include <linux/platform_device.h> |
|
#include <linux/property.h> |
|
#include <linux/types.h> |
|
#include <linux/workqueue.h> |
|
|
|
#include <linux/surface_aggregator/controller.h> |
|
#include <linux/surface_aggregator/device.h> |
|
|
|
|
|
/* -- Device registry. ------------------------------------------------------ */ |
|
|
|
/* |
|
* SSAM device names follow the SSAM module alias, meaning they are prefixed |
|
* with 'ssam:', followed by domain, category, target ID, instance ID, and |
|
* function, each encoded as two-digit hexadecimal, separated by ':'. In other |
|
* words, it follows the scheme |
|
* |
|
* ssam:dd:cc:tt:ii:ff |
|
* |
|
* Where, 'dd', 'cc', 'tt', 'ii', and 'ff' are the two-digit hexadecimal |
|
* values mentioned above, respectively. |
|
*/ |
|
|
|
/* Root node. */ |
|
static const struct software_node ssam_node_root = { |
|
.name = "ssam_platform_hub", |
|
}; |
|
|
|
/* Base device hub (devices attached to Surface Book 3 base). */ |
|
static const struct software_node ssam_node_hub_base = { |
|
.name = "ssam:00:00:02:00:00", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* AC adapter. */ |
|
static const struct software_node ssam_node_bat_ac = { |
|
.name = "ssam:01:02:01:01:01", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* Primary battery. */ |
|
static const struct software_node ssam_node_bat_main = { |
|
.name = "ssam:01:02:01:01:00", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* Secondary battery (Surface Book 3). */ |
|
static const struct software_node ssam_node_bat_sb3base = { |
|
.name = "ssam:01:02:02:01:00", |
|
.parent = &ssam_node_hub_base, |
|
}; |
|
|
|
/* Platform profile / performance-mode device. */ |
|
static const struct software_node ssam_node_tmp_pprof = { |
|
.name = "ssam:01:03:01:00:01", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* DTX / detachment-system device (Surface Book 3). */ |
|
static const struct software_node ssam_node_bas_dtx = { |
|
.name = "ssam:01:11:01:00:00", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* HID keyboard (TID1). */ |
|
static const struct software_node ssam_node_hid_tid1_keyboard = { |
|
.name = "ssam:01:15:01:01:00", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* HID pen stash (TID1; pen taken / stashed away evens). */ |
|
static const struct software_node ssam_node_hid_tid1_penstash = { |
|
.name = "ssam:01:15:01:02:00", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* HID touchpad (TID1). */ |
|
static const struct software_node ssam_node_hid_tid1_touchpad = { |
|
.name = "ssam:01:15:01:03:00", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* HID device instance 6 (TID1, unknown HID device). */ |
|
static const struct software_node ssam_node_hid_tid1_iid6 = { |
|
.name = "ssam:01:15:01:06:00", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* HID device instance 7 (TID1, unknown HID device). */ |
|
static const struct software_node ssam_node_hid_tid1_iid7 = { |
|
.name = "ssam:01:15:01:07:00", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* HID system controls (TID1). */ |
|
static const struct software_node ssam_node_hid_tid1_sysctrl = { |
|
.name = "ssam:01:15:01:08:00", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* HID keyboard. */ |
|
static const struct software_node ssam_node_hid_main_keyboard = { |
|
.name = "ssam:01:15:02:01:00", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* HID touchpad. */ |
|
static const struct software_node ssam_node_hid_main_touchpad = { |
|
.name = "ssam:01:15:02:03:00", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* HID device instance 5 (unknown HID device). */ |
|
static const struct software_node ssam_node_hid_main_iid5 = { |
|
.name = "ssam:01:15:02:05:00", |
|
.parent = &ssam_node_root, |
|
}; |
|
|
|
/* HID keyboard (base hub). */ |
|
static const struct software_node ssam_node_hid_base_keyboard = { |
|
.name = "ssam:01:15:02:01:00", |
|
.parent = &ssam_node_hub_base, |
|
}; |
|
|
|
/* HID touchpad (base hub). */ |
|
static const struct software_node ssam_node_hid_base_touchpad = { |
|
.name = "ssam:01:15:02:03:00", |
|
.parent = &ssam_node_hub_base, |
|
}; |
|
|
|
/* HID device instance 5 (unknown HID device, base hub). */ |
|
static const struct software_node ssam_node_hid_base_iid5 = { |
|
.name = "ssam:01:15:02:05:00", |
|
.parent = &ssam_node_hub_base, |
|
}; |
|
|
|
/* HID device instance 6 (unknown HID device, base hub). */ |
|
static const struct software_node ssam_node_hid_base_iid6 = { |
|
.name = "ssam:01:15:02:06:00", |
|
.parent = &ssam_node_hub_base, |
|
}; |
|
|
|
/* |
|
* Devices for 5th- and 6th-generations models: |
|
* - Surface Book 2, |
|
* - Surface Laptop 1 and 2, |
|
* - Surface Pro 5 and 6. |
|
*/ |
|
static const struct software_node *ssam_node_group_gen5[] = { |
|
&ssam_node_root, |
|
&ssam_node_tmp_pprof, |
|
NULL, |
|
}; |
|
|
|
/* Devices for Surface Book 3. */ |
|
static const struct software_node *ssam_node_group_sb3[] = { |
|
&ssam_node_root, |
|
&ssam_node_hub_base, |
|
&ssam_node_bat_ac, |
|
&ssam_node_bat_main, |
|
&ssam_node_bat_sb3base, |
|
&ssam_node_tmp_pprof, |
|
&ssam_node_bas_dtx, |
|
&ssam_node_hid_base_keyboard, |
|
&ssam_node_hid_base_touchpad, |
|
&ssam_node_hid_base_iid5, |
|
&ssam_node_hid_base_iid6, |
|
NULL, |
|
}; |
|
|
|
/* Devices for Surface Laptop 3 and 4. */ |
|
static const struct software_node *ssam_node_group_sl3[] = { |
|
&ssam_node_root, |
|
&ssam_node_bat_ac, |
|
&ssam_node_bat_main, |
|
&ssam_node_tmp_pprof, |
|
&ssam_node_hid_main_keyboard, |
|
&ssam_node_hid_main_touchpad, |
|
&ssam_node_hid_main_iid5, |
|
NULL, |
|
}; |
|
|
|
/* Devices for Surface Laptop Studio. */ |
|
static const struct software_node *ssam_node_group_sls[] = { |
|
&ssam_node_root, |
|
&ssam_node_bat_ac, |
|
&ssam_node_bat_main, |
|
&ssam_node_tmp_pprof, |
|
&ssam_node_hid_tid1_keyboard, |
|
&ssam_node_hid_tid1_penstash, |
|
&ssam_node_hid_tid1_touchpad, |
|
&ssam_node_hid_tid1_iid6, |
|
&ssam_node_hid_tid1_iid7, |
|
&ssam_node_hid_tid1_sysctrl, |
|
NULL, |
|
}; |
|
|
|
/* Devices for Surface Laptop Go. */ |
|
static const struct software_node *ssam_node_group_slg1[] = { |
|
&ssam_node_root, |
|
&ssam_node_bat_ac, |
|
&ssam_node_bat_main, |
|
&ssam_node_tmp_pprof, |
|
NULL, |
|
}; |
|
|
|
/* Devices for Surface Pro 7 and Surface Pro 7+. */ |
|
static const struct software_node *ssam_node_group_sp7[] = { |
|
&ssam_node_root, |
|
&ssam_node_bat_ac, |
|
&ssam_node_bat_main, |
|
&ssam_node_tmp_pprof, |
|
NULL, |
|
}; |
|
|
|
static const struct software_node *ssam_node_group_sp8[] = { |
|
&ssam_node_root, |
|
&ssam_node_bat_ac, |
|
&ssam_node_bat_main, |
|
&ssam_node_tmp_pprof, |
|
/* TODO: Add support for keyboard cover. */ |
|
NULL, |
|
}; |
|
|
|
|
|
/* -- Device registry helper functions. ------------------------------------- */ |
|
|
|
static int ssam_uid_from_string(const char *str, struct ssam_device_uid *uid) |
|
{ |
|
u8 d, tc, tid, iid, fn; |
|
int n; |
|
|
|
n = sscanf(str, "ssam:%hhx:%hhx:%hhx:%hhx:%hhx", &d, &tc, &tid, &iid, &fn); |
|
if (n != 5) |
|
return -EINVAL; |
|
|
|
uid->domain = d; |
|
uid->category = tc; |
|
uid->target = tid; |
|
uid->instance = iid; |
|
uid->function = fn; |
|
|
|
return 0; |
|
} |
|
|
|
static int ssam_hub_add_device(struct device *parent, struct ssam_controller *ctrl, |
|
struct fwnode_handle *node) |
|
{ |
|
struct ssam_device_uid uid; |
|
struct ssam_device *sdev; |
|
int status; |
|
|
|
status = ssam_uid_from_string(fwnode_get_name(node), &uid); |
|
if (status) |
|
return status; |
|
|
|
sdev = ssam_device_alloc(ctrl, uid); |
|
if (!sdev) |
|
return -ENOMEM; |
|
|
|
sdev->dev.parent = parent; |
|
sdev->dev.fwnode = node; |
|
|
|
status = ssam_device_add(sdev); |
|
if (status) |
|
ssam_device_put(sdev); |
|
|
|
return status; |
|
} |
|
|
|
static int ssam_hub_register_clients(struct device *parent, struct ssam_controller *ctrl, |
|
struct fwnode_handle *node) |
|
{ |
|
struct fwnode_handle *child; |
|
int status; |
|
|
|
fwnode_for_each_child_node(node, child) { |
|
/* |
|
* Try to add the device specified in the firmware node. If |
|
* this fails with -EINVAL, the node does not specify any SSAM |
|
* device, so ignore it and continue with the next one. |
|
*/ |
|
|
|
status = ssam_hub_add_device(parent, ctrl, child); |
|
if (status && status != -EINVAL) |
|
goto err; |
|
} |
|
|
|
return 0; |
|
err: |
|
ssam_remove_clients(parent); |
|
return status; |
|
} |
|
|
|
|
|
/* -- SSAM base-hub driver. ------------------------------------------------- */ |
|
|
|
/* |
|
* Some devices (especially battery) may need a bit of time to be fully usable |
|
* after being (re-)connected. This delay has been determined via |
|
* experimentation. |
|
*/ |
|
#define SSAM_BASE_UPDATE_CONNECT_DELAY msecs_to_jiffies(2500) |
|
|
|
enum ssam_base_hub_state { |
|
SSAM_BASE_HUB_UNINITIALIZED, |
|
SSAM_BASE_HUB_CONNECTED, |
|
SSAM_BASE_HUB_DISCONNECTED, |
|
}; |
|
|
|
struct ssam_base_hub { |
|
struct ssam_device *sdev; |
|
|
|
enum ssam_base_hub_state state; |
|
struct delayed_work update_work; |
|
|
|
struct ssam_event_notifier notif; |
|
}; |
|
|
|
SSAM_DEFINE_SYNC_REQUEST_R(ssam_bas_query_opmode, u8, { |
|
.target_category = SSAM_SSH_TC_BAS, |
|
.target_id = 0x01, |
|
.command_id = 0x0d, |
|
.instance_id = 0x00, |
|
}); |
|
|
|
#define SSAM_BAS_OPMODE_TABLET 0x00 |
|
#define SSAM_EVENT_BAS_CID_CONNECTION 0x0c |
|
|
|
static int ssam_base_hub_query_state(struct ssam_base_hub *hub, enum ssam_base_hub_state *state) |
|
{ |
|
u8 opmode; |
|
int status; |
|
|
|
status = ssam_retry(ssam_bas_query_opmode, hub->sdev->ctrl, &opmode); |
|
if (status < 0) { |
|
dev_err(&hub->sdev->dev, "failed to query base state: %d\n", status); |
|
return status; |
|
} |
|
|
|
if (opmode != SSAM_BAS_OPMODE_TABLET) |
|
*state = SSAM_BASE_HUB_CONNECTED; |
|
else |
|
*state = SSAM_BASE_HUB_DISCONNECTED; |
|
|
|
return 0; |
|
} |
|
|
|
static ssize_t ssam_base_hub_state_show(struct device *dev, struct device_attribute *attr, |
|
char *buf) |
|
{ |
|
struct ssam_base_hub *hub = dev_get_drvdata(dev); |
|
bool connected = hub->state == SSAM_BASE_HUB_CONNECTED; |
|
|
|
return sysfs_emit(buf, "%d\n", connected); |
|
} |
|
|
|
static struct device_attribute ssam_base_hub_attr_state = |
|
__ATTR(state, 0444, ssam_base_hub_state_show, NULL); |
|
|
|
static struct attribute *ssam_base_hub_attrs[] = { |
|
&ssam_base_hub_attr_state.attr, |
|
NULL, |
|
}; |
|
|
|
static const struct attribute_group ssam_base_hub_group = { |
|
.attrs = ssam_base_hub_attrs, |
|
}; |
|
|
|
static void ssam_base_hub_update_workfn(struct work_struct *work) |
|
{ |
|
struct ssam_base_hub *hub = container_of(work, struct ssam_base_hub, update_work.work); |
|
struct fwnode_handle *node = dev_fwnode(&hub->sdev->dev); |
|
enum ssam_base_hub_state state; |
|
int status = 0; |
|
|
|
status = ssam_base_hub_query_state(hub, &state); |
|
if (status) |
|
return; |
|
|
|
if (hub->state == state) |
|
return; |
|
hub->state = state; |
|
|
|
if (hub->state == SSAM_BASE_HUB_CONNECTED) |
|
status = ssam_hub_register_clients(&hub->sdev->dev, hub->sdev->ctrl, node); |
|
else |
|
ssam_remove_clients(&hub->sdev->dev); |
|
|
|
if (status) |
|
dev_err(&hub->sdev->dev, "failed to update base-hub devices: %d\n", status); |
|
} |
|
|
|
static u32 ssam_base_hub_notif(struct ssam_event_notifier *nf, const struct ssam_event *event) |
|
{ |
|
struct ssam_base_hub *hub = container_of(nf, struct ssam_base_hub, notif); |
|
unsigned long delay; |
|
|
|
if (event->command_id != SSAM_EVENT_BAS_CID_CONNECTION) |
|
return 0; |
|
|
|
if (event->length < 1) { |
|
dev_err(&hub->sdev->dev, "unexpected payload size: %u\n", event->length); |
|
return 0; |
|
} |
|
|
|
/* |
|
* Delay update when the base is being connected to give devices/EC |
|
* some time to set up. |
|
*/ |
|
delay = event->data[0] ? SSAM_BASE_UPDATE_CONNECT_DELAY : 0; |
|
|
|
schedule_delayed_work(&hub->update_work, delay); |
|
|
|
/* |
|
* Do not return SSAM_NOTIF_HANDLED: The event should be picked up and |
|
* consumed by the detachment system driver. We're just a (more or less) |
|
* silent observer. |
|
*/ |
|
return 0; |
|
} |
|
|
|
static int __maybe_unused ssam_base_hub_resume(struct device *dev) |
|
{ |
|
struct ssam_base_hub *hub = dev_get_drvdata(dev); |
|
|
|
schedule_delayed_work(&hub->update_work, 0); |
|
return 0; |
|
} |
|
static SIMPLE_DEV_PM_OPS(ssam_base_hub_pm_ops, NULL, ssam_base_hub_resume); |
|
|
|
static int ssam_base_hub_probe(struct ssam_device *sdev) |
|
{ |
|
struct ssam_base_hub *hub; |
|
int status; |
|
|
|
hub = devm_kzalloc(&sdev->dev, sizeof(*hub), GFP_KERNEL); |
|
if (!hub) |
|
return -ENOMEM; |
|
|
|
hub->sdev = sdev; |
|
hub->state = SSAM_BASE_HUB_UNINITIALIZED; |
|
|
|
hub->notif.base.priority = INT_MAX; /* This notifier should run first. */ |
|
hub->notif.base.fn = ssam_base_hub_notif; |
|
hub->notif.event.reg = SSAM_EVENT_REGISTRY_SAM; |
|
hub->notif.event.id.target_category = SSAM_SSH_TC_BAS, |
|
hub->notif.event.id.instance = 0, |
|
hub->notif.event.mask = SSAM_EVENT_MASK_NONE; |
|
hub->notif.event.flags = SSAM_EVENT_SEQUENCED; |
|
|
|
INIT_DELAYED_WORK(&hub->update_work, ssam_base_hub_update_workfn); |
|
|
|
ssam_device_set_drvdata(sdev, hub); |
|
|
|
status = ssam_notifier_register(sdev->ctrl, &hub->notif); |
|
if (status) |
|
return status; |
|
|
|
status = sysfs_create_group(&sdev->dev.kobj, &ssam_base_hub_group); |
|
if (status) |
|
goto err; |
|
|
|
schedule_delayed_work(&hub->update_work, 0); |
|
return 0; |
|
|
|
err: |
|
ssam_notifier_unregister(sdev->ctrl, &hub->notif); |
|
cancel_delayed_work_sync(&hub->update_work); |
|
ssam_remove_clients(&sdev->dev); |
|
return status; |
|
} |
|
|
|
static void ssam_base_hub_remove(struct ssam_device *sdev) |
|
{ |
|
struct ssam_base_hub *hub = ssam_device_get_drvdata(sdev); |
|
|
|
sysfs_remove_group(&sdev->dev.kobj, &ssam_base_hub_group); |
|
|
|
ssam_notifier_unregister(sdev->ctrl, &hub->notif); |
|
cancel_delayed_work_sync(&hub->update_work); |
|
ssam_remove_clients(&sdev->dev); |
|
} |
|
|
|
static const struct ssam_device_id ssam_base_hub_match[] = { |
|
{ SSAM_VDEV(HUB, 0x02, SSAM_ANY_IID, 0x00) }, |
|
{ }, |
|
}; |
|
|
|
static struct ssam_device_driver ssam_base_hub_driver = { |
|
.probe = ssam_base_hub_probe, |
|
.remove = ssam_base_hub_remove, |
|
.match_table = ssam_base_hub_match, |
|
.driver = { |
|
.name = "surface_aggregator_base_hub", |
|
.probe_type = PROBE_PREFER_ASYNCHRONOUS, |
|
.pm = &ssam_base_hub_pm_ops, |
|
}, |
|
}; |
|
|
|
|
|
/* -- SSAM platform/meta-hub driver. ---------------------------------------- */ |
|
|
|
static const struct acpi_device_id ssam_platform_hub_match[] = { |
|
/* Surface Pro 4, 5, and 6 (OMBR < 0x10) */ |
|
{ "MSHW0081", (unsigned long)ssam_node_group_gen5 }, |
|
|
|
/* Surface Pro 6 (OMBR >= 0x10) */ |
|
{ "MSHW0111", (unsigned long)ssam_node_group_gen5 }, |
|
|
|
/* Surface Pro 7 */ |
|
{ "MSHW0116", (unsigned long)ssam_node_group_sp7 }, |
|
|
|
/* Surface Pro 7+ */ |
|
{ "MSHW0119", (unsigned long)ssam_node_group_sp7 }, |
|
|
|
/* Surface Pro 8 */ |
|
{ "MSHW0263", (unsigned long)ssam_node_group_sp8 }, |
|
|
|
/* Surface Book 2 */ |
|
{ "MSHW0107", (unsigned long)ssam_node_group_gen5 }, |
|
|
|
/* Surface Book 3 */ |
|
{ "MSHW0117", (unsigned long)ssam_node_group_sb3 }, |
|
|
|
/* Surface Laptop 1 */ |
|
{ "MSHW0086", (unsigned long)ssam_node_group_gen5 }, |
|
|
|
/* Surface Laptop 2 */ |
|
{ "MSHW0112", (unsigned long)ssam_node_group_gen5 }, |
|
|
|
/* Surface Laptop 3 (13", Intel) */ |
|
{ "MSHW0114", (unsigned long)ssam_node_group_sl3 }, |
|
|
|
/* Surface Laptop 3 (15", AMD) and 4 (15", AMD) */ |
|
{ "MSHW0110", (unsigned long)ssam_node_group_sl3 }, |
|
|
|
/* Surface Laptop 4 (13", Intel) */ |
|
{ "MSHW0250", (unsigned long)ssam_node_group_sl3 }, |
|
|
|
/* Surface Laptop Go 1 */ |
|
{ "MSHW0118", (unsigned long)ssam_node_group_slg1 }, |
|
|
|
/* Surface Laptop Studio */ |
|
{ "MSHW0123", (unsigned long)ssam_node_group_sls }, |
|
|
|
{ }, |
|
}; |
|
MODULE_DEVICE_TABLE(acpi, ssam_platform_hub_match); |
|
|
|
static int ssam_platform_hub_probe(struct platform_device *pdev) |
|
{ |
|
const struct software_node **nodes; |
|
struct ssam_controller *ctrl; |
|
struct fwnode_handle *root; |
|
int status; |
|
|
|
nodes = (const struct software_node **)acpi_device_get_match_data(&pdev->dev); |
|
if (!nodes) |
|
return -ENODEV; |
|
|
|
/* |
|
* As we're adding the SSAM client devices as children under this device |
|
* and not the SSAM controller, we need to add a device link to the |
|
* controller to ensure that we remove all of our devices before the |
|
* controller is removed. This also guarantees proper ordering for |
|
* suspend/resume of the devices on this hub. |
|
*/ |
|
ctrl = ssam_client_bind(&pdev->dev); |
|
if (IS_ERR(ctrl)) |
|
return PTR_ERR(ctrl) == -ENODEV ? -EPROBE_DEFER : PTR_ERR(ctrl); |
|
|
|
status = software_node_register_node_group(nodes); |
|
if (status) |
|
return status; |
|
|
|
root = software_node_fwnode(&ssam_node_root); |
|
if (!root) { |
|
software_node_unregister_node_group(nodes); |
|
return -ENOENT; |
|
} |
|
|
|
set_secondary_fwnode(&pdev->dev, root); |
|
|
|
status = ssam_hub_register_clients(&pdev->dev, ctrl, root); |
|
if (status) { |
|
set_secondary_fwnode(&pdev->dev, NULL); |
|
software_node_unregister_node_group(nodes); |
|
} |
|
|
|
platform_set_drvdata(pdev, nodes); |
|
return status; |
|
} |
|
|
|
static int ssam_platform_hub_remove(struct platform_device *pdev) |
|
{ |
|
const struct software_node **nodes = platform_get_drvdata(pdev); |
|
|
|
ssam_remove_clients(&pdev->dev); |
|
set_secondary_fwnode(&pdev->dev, NULL); |
|
software_node_unregister_node_group(nodes); |
|
return 0; |
|
} |
|
|
|
static struct platform_driver ssam_platform_hub_driver = { |
|
.probe = ssam_platform_hub_probe, |
|
.remove = ssam_platform_hub_remove, |
|
.driver = { |
|
.name = "surface_aggregator_platform_hub", |
|
.acpi_match_table = ssam_platform_hub_match, |
|
.probe_type = PROBE_PREFER_ASYNCHRONOUS, |
|
}, |
|
}; |
|
|
|
|
|
/* -- Module initialization. ------------------------------------------------ */ |
|
|
|
static int __init ssam_device_hub_init(void) |
|
{ |
|
int status; |
|
|
|
status = platform_driver_register(&ssam_platform_hub_driver); |
|
if (status) |
|
return status; |
|
|
|
status = ssam_device_driver_register(&ssam_base_hub_driver); |
|
if (status) |
|
platform_driver_unregister(&ssam_platform_hub_driver); |
|
|
|
return status; |
|
} |
|
module_init(ssam_device_hub_init); |
|
|
|
static void __exit ssam_device_hub_exit(void) |
|
{ |
|
ssam_device_driver_unregister(&ssam_base_hub_driver); |
|
platform_driver_unregister(&ssam_platform_hub_driver); |
|
} |
|
module_exit(ssam_device_hub_exit); |
|
|
|
MODULE_AUTHOR("Maximilian Luz <[email protected]>"); |
|
MODULE_DESCRIPTION("Device-registry for Surface System Aggregator Module"); |
|
MODULE_LICENSE("GPL");
|
|
|