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.
632 lines
15 KiB
632 lines
15 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* Hardware monitoring driver for UCD90xxx Sequencer and System Health |
|
* Controller series |
|
* |
|
* Copyright (C) 2011 Ericsson AB. |
|
*/ |
|
|
|
#include <linux/debugfs.h> |
|
#include <linux/kernel.h> |
|
#include <linux/module.h> |
|
#include <linux/of_device.h> |
|
#include <linux/init.h> |
|
#include <linux/err.h> |
|
#include <linux/slab.h> |
|
#include <linux/i2c.h> |
|
#include <linux/pmbus.h> |
|
#include <linux/gpio/driver.h> |
|
#include "pmbus.h" |
|
|
|
enum chips { ucd9000, ucd90120, ucd90124, ucd90160, ucd90320, ucd9090, |
|
ucd90910 }; |
|
|
|
#define UCD9000_MONITOR_CONFIG 0xd5 |
|
#define UCD9000_NUM_PAGES 0xd6 |
|
#define UCD9000_FAN_CONFIG_INDEX 0xe7 |
|
#define UCD9000_FAN_CONFIG 0xe8 |
|
#define UCD9000_MFR_STATUS 0xf3 |
|
#define UCD9000_GPIO_SELECT 0xfa |
|
#define UCD9000_GPIO_CONFIG 0xfb |
|
#define UCD9000_DEVICE_ID 0xfd |
|
|
|
/* GPIO CONFIG bits */ |
|
#define UCD9000_GPIO_CONFIG_ENABLE BIT(0) |
|
#define UCD9000_GPIO_CONFIG_OUT_ENABLE BIT(1) |
|
#define UCD9000_GPIO_CONFIG_OUT_VALUE BIT(2) |
|
#define UCD9000_GPIO_CONFIG_STATUS BIT(3) |
|
#define UCD9000_GPIO_INPUT 0 |
|
#define UCD9000_GPIO_OUTPUT 1 |
|
|
|
#define UCD9000_MON_TYPE(x) (((x) >> 5) & 0x07) |
|
#define UCD9000_MON_PAGE(x) ((x) & 0x1f) |
|
|
|
#define UCD9000_MON_VOLTAGE 1 |
|
#define UCD9000_MON_TEMPERATURE 2 |
|
#define UCD9000_MON_CURRENT 3 |
|
#define UCD9000_MON_VOLTAGE_HW 4 |
|
|
|
#define UCD9000_NUM_FAN 4 |
|
|
|
#define UCD9000_GPIO_NAME_LEN 16 |
|
#define UCD9090_NUM_GPIOS 23 |
|
#define UCD901XX_NUM_GPIOS 26 |
|
#define UCD90320_NUM_GPIOS 84 |
|
#define UCD90910_NUM_GPIOS 26 |
|
|
|
#define UCD9000_DEBUGFS_NAME_LEN 24 |
|
#define UCD9000_GPI_COUNT 8 |
|
#define UCD90320_GPI_COUNT 32 |
|
|
|
struct ucd9000_data { |
|
u8 fan_data[UCD9000_NUM_FAN][I2C_SMBUS_BLOCK_MAX]; |
|
struct pmbus_driver_info info; |
|
#ifdef CONFIG_GPIOLIB |
|
struct gpio_chip gpio; |
|
#endif |
|
struct dentry *debugfs; |
|
}; |
|
#define to_ucd9000_data(_info) container_of(_info, struct ucd9000_data, info) |
|
|
|
struct ucd9000_debugfs_entry { |
|
struct i2c_client *client; |
|
u8 index; |
|
}; |
|
|
|
static int ucd9000_get_fan_config(struct i2c_client *client, int fan) |
|
{ |
|
int fan_config = 0; |
|
struct ucd9000_data *data |
|
= to_ucd9000_data(pmbus_get_driver_info(client)); |
|
|
|
if (data->fan_data[fan][3] & 1) |
|
fan_config |= PB_FAN_2_INSTALLED; /* Use lower bit position */ |
|
|
|
/* Pulses/revolution */ |
|
fan_config |= (data->fan_data[fan][3] & 0x06) >> 1; |
|
|
|
return fan_config; |
|
} |
|
|
|
static int ucd9000_read_byte_data(struct i2c_client *client, int page, int reg) |
|
{ |
|
int ret = 0; |
|
int fan_config; |
|
|
|
switch (reg) { |
|
case PMBUS_FAN_CONFIG_12: |
|
if (page > 0) |
|
return -ENXIO; |
|
|
|
ret = ucd9000_get_fan_config(client, 0); |
|
if (ret < 0) |
|
return ret; |
|
fan_config = ret << 4; |
|
ret = ucd9000_get_fan_config(client, 1); |
|
if (ret < 0) |
|
return ret; |
|
fan_config |= ret; |
|
ret = fan_config; |
|
break; |
|
case PMBUS_FAN_CONFIG_34: |
|
if (page > 0) |
|
return -ENXIO; |
|
|
|
ret = ucd9000_get_fan_config(client, 2); |
|
if (ret < 0) |
|
return ret; |
|
fan_config = ret << 4; |
|
ret = ucd9000_get_fan_config(client, 3); |
|
if (ret < 0) |
|
return ret; |
|
fan_config |= ret; |
|
ret = fan_config; |
|
break; |
|
default: |
|
ret = -ENODATA; |
|
break; |
|
} |
|
return ret; |
|
} |
|
|
|
static const struct i2c_device_id ucd9000_id[] = { |
|
{"ucd9000", ucd9000}, |
|
{"ucd90120", ucd90120}, |
|
{"ucd90124", ucd90124}, |
|
{"ucd90160", ucd90160}, |
|
{"ucd90320", ucd90320}, |
|
{"ucd9090", ucd9090}, |
|
{"ucd90910", ucd90910}, |
|
{} |
|
}; |
|
MODULE_DEVICE_TABLE(i2c, ucd9000_id); |
|
|
|
static const struct of_device_id __maybe_unused ucd9000_of_match[] = { |
|
{ |
|
.compatible = "ti,ucd9000", |
|
.data = (void *)ucd9000 |
|
}, |
|
{ |
|
.compatible = "ti,ucd90120", |
|
.data = (void *)ucd90120 |
|
}, |
|
{ |
|
.compatible = "ti,ucd90124", |
|
.data = (void *)ucd90124 |
|
}, |
|
{ |
|
.compatible = "ti,ucd90160", |
|
.data = (void *)ucd90160 |
|
}, |
|
{ |
|
.compatible = "ti,ucd90320", |
|
.data = (void *)ucd90320 |
|
}, |
|
{ |
|
.compatible = "ti,ucd9090", |
|
.data = (void *)ucd9090 |
|
}, |
|
{ |
|
.compatible = "ti,ucd90910", |
|
.data = (void *)ucd90910 |
|
}, |
|
{ }, |
|
}; |
|
MODULE_DEVICE_TABLE(of, ucd9000_of_match); |
|
|
|
#ifdef CONFIG_GPIOLIB |
|
static int ucd9000_gpio_read_config(struct i2c_client *client, |
|
unsigned int offset) |
|
{ |
|
int ret; |
|
|
|
/* No page set required */ |
|
ret = i2c_smbus_write_byte_data(client, UCD9000_GPIO_SELECT, offset); |
|
if (ret < 0) |
|
return ret; |
|
|
|
return i2c_smbus_read_byte_data(client, UCD9000_GPIO_CONFIG); |
|
} |
|
|
|
static int ucd9000_gpio_get(struct gpio_chip *gc, unsigned int offset) |
|
{ |
|
struct i2c_client *client = gpiochip_get_data(gc); |
|
int ret; |
|
|
|
ret = ucd9000_gpio_read_config(client, offset); |
|
if (ret < 0) |
|
return ret; |
|
|
|
return !!(ret & UCD9000_GPIO_CONFIG_STATUS); |
|
} |
|
|
|
static void ucd9000_gpio_set(struct gpio_chip *gc, unsigned int offset, |
|
int value) |
|
{ |
|
struct i2c_client *client = gpiochip_get_data(gc); |
|
int ret; |
|
|
|
ret = ucd9000_gpio_read_config(client, offset); |
|
if (ret < 0) { |
|
dev_dbg(&client->dev, "failed to read GPIO %d config: %d\n", |
|
offset, ret); |
|
return; |
|
} |
|
|
|
if (value) { |
|
if (ret & UCD9000_GPIO_CONFIG_STATUS) |
|
return; |
|
|
|
ret |= UCD9000_GPIO_CONFIG_STATUS; |
|
} else { |
|
if (!(ret & UCD9000_GPIO_CONFIG_STATUS)) |
|
return; |
|
|
|
ret &= ~UCD9000_GPIO_CONFIG_STATUS; |
|
} |
|
|
|
ret |= UCD9000_GPIO_CONFIG_ENABLE; |
|
|
|
/* Page set not required */ |
|
ret = i2c_smbus_write_byte_data(client, UCD9000_GPIO_CONFIG, ret); |
|
if (ret < 0) { |
|
dev_dbg(&client->dev, "Failed to write GPIO %d config: %d\n", |
|
offset, ret); |
|
return; |
|
} |
|
|
|
ret &= ~UCD9000_GPIO_CONFIG_ENABLE; |
|
|
|
ret = i2c_smbus_write_byte_data(client, UCD9000_GPIO_CONFIG, ret); |
|
if (ret < 0) |
|
dev_dbg(&client->dev, "Failed to write GPIO %d config: %d\n", |
|
offset, ret); |
|
} |
|
|
|
static int ucd9000_gpio_get_direction(struct gpio_chip *gc, |
|
unsigned int offset) |
|
{ |
|
struct i2c_client *client = gpiochip_get_data(gc); |
|
int ret; |
|
|
|
ret = ucd9000_gpio_read_config(client, offset); |
|
if (ret < 0) |
|
return ret; |
|
|
|
return !(ret & UCD9000_GPIO_CONFIG_OUT_ENABLE); |
|
} |
|
|
|
static int ucd9000_gpio_set_direction(struct gpio_chip *gc, |
|
unsigned int offset, bool direction_out, |
|
int requested_out) |
|
{ |
|
struct i2c_client *client = gpiochip_get_data(gc); |
|
int ret, config, out_val; |
|
|
|
ret = ucd9000_gpio_read_config(client, offset); |
|
if (ret < 0) |
|
return ret; |
|
|
|
if (direction_out) { |
|
out_val = requested_out ? UCD9000_GPIO_CONFIG_OUT_VALUE : 0; |
|
|
|
if (ret & UCD9000_GPIO_CONFIG_OUT_ENABLE) { |
|
if ((ret & UCD9000_GPIO_CONFIG_OUT_VALUE) == out_val) |
|
return 0; |
|
} else { |
|
ret |= UCD9000_GPIO_CONFIG_OUT_ENABLE; |
|
} |
|
|
|
if (out_val) |
|
ret |= UCD9000_GPIO_CONFIG_OUT_VALUE; |
|
else |
|
ret &= ~UCD9000_GPIO_CONFIG_OUT_VALUE; |
|
|
|
} else { |
|
if (!(ret & UCD9000_GPIO_CONFIG_OUT_ENABLE)) |
|
return 0; |
|
|
|
ret &= ~UCD9000_GPIO_CONFIG_OUT_ENABLE; |
|
} |
|
|
|
ret |= UCD9000_GPIO_CONFIG_ENABLE; |
|
config = ret; |
|
|
|
/* Page set not required */ |
|
ret = i2c_smbus_write_byte_data(client, UCD9000_GPIO_CONFIG, config); |
|
if (ret < 0) |
|
return ret; |
|
|
|
config &= ~UCD9000_GPIO_CONFIG_ENABLE; |
|
|
|
return i2c_smbus_write_byte_data(client, UCD9000_GPIO_CONFIG, config); |
|
} |
|
|
|
static int ucd9000_gpio_direction_input(struct gpio_chip *gc, |
|
unsigned int offset) |
|
{ |
|
return ucd9000_gpio_set_direction(gc, offset, UCD9000_GPIO_INPUT, 0); |
|
} |
|
|
|
static int ucd9000_gpio_direction_output(struct gpio_chip *gc, |
|
unsigned int offset, int val) |
|
{ |
|
return ucd9000_gpio_set_direction(gc, offset, UCD9000_GPIO_OUTPUT, |
|
val); |
|
} |
|
|
|
static void ucd9000_probe_gpio(struct i2c_client *client, |
|
const struct i2c_device_id *mid, |
|
struct ucd9000_data *data) |
|
{ |
|
int rc; |
|
|
|
switch (mid->driver_data) { |
|
case ucd9090: |
|
data->gpio.ngpio = UCD9090_NUM_GPIOS; |
|
break; |
|
case ucd90120: |
|
case ucd90124: |
|
case ucd90160: |
|
data->gpio.ngpio = UCD901XX_NUM_GPIOS; |
|
break; |
|
case ucd90320: |
|
data->gpio.ngpio = UCD90320_NUM_GPIOS; |
|
break; |
|
case ucd90910: |
|
data->gpio.ngpio = UCD90910_NUM_GPIOS; |
|
break; |
|
default: |
|
return; /* GPIO support is optional. */ |
|
} |
|
|
|
/* |
|
* Pinmux support has not been added to the new gpio_chip. |
|
* This support should be added when possible given the mux |
|
* behavior of these IO devices. |
|
*/ |
|
data->gpio.label = client->name; |
|
data->gpio.get_direction = ucd9000_gpio_get_direction; |
|
data->gpio.direction_input = ucd9000_gpio_direction_input; |
|
data->gpio.direction_output = ucd9000_gpio_direction_output; |
|
data->gpio.get = ucd9000_gpio_get; |
|
data->gpio.set = ucd9000_gpio_set; |
|
data->gpio.can_sleep = true; |
|
data->gpio.base = -1; |
|
data->gpio.parent = &client->dev; |
|
|
|
rc = devm_gpiochip_add_data(&client->dev, &data->gpio, client); |
|
if (rc) |
|
dev_warn(&client->dev, "Could not add gpiochip: %d\n", rc); |
|
} |
|
#else |
|
static void ucd9000_probe_gpio(struct i2c_client *client, |
|
const struct i2c_device_id *mid, |
|
struct ucd9000_data *data) |
|
{ |
|
} |
|
#endif /* CONFIG_GPIOLIB */ |
|
|
|
#ifdef CONFIG_DEBUG_FS |
|
static int ucd9000_get_mfr_status(struct i2c_client *client, u8 *buffer) |
|
{ |
|
int ret = pmbus_set_page(client, 0, 0xff); |
|
|
|
if (ret < 0) |
|
return ret; |
|
|
|
return i2c_smbus_read_block_data(client, UCD9000_MFR_STATUS, buffer); |
|
} |
|
|
|
static int ucd9000_debugfs_show_mfr_status_bit(void *data, u64 *val) |
|
{ |
|
struct ucd9000_debugfs_entry *entry = data; |
|
struct i2c_client *client = entry->client; |
|
u8 buffer[I2C_SMBUS_BLOCK_MAX]; |
|
int ret, i; |
|
|
|
ret = ucd9000_get_mfr_status(client, buffer); |
|
if (ret < 0) |
|
return ret; |
|
|
|
/* |
|
* GPI fault bits are in sets of 8, two bytes from end of response. |
|
*/ |
|
i = ret - 3 - entry->index / 8; |
|
if (i >= 0) |
|
*val = !!(buffer[i] & BIT(entry->index % 8)); |
|
|
|
return 0; |
|
} |
|
DEFINE_DEBUGFS_ATTRIBUTE(ucd9000_debugfs_mfr_status_bit, |
|
ucd9000_debugfs_show_mfr_status_bit, NULL, "%1lld\n"); |
|
|
|
static ssize_t ucd9000_debugfs_read_mfr_status(struct file *file, |
|
char __user *buf, size_t count, |
|
loff_t *ppos) |
|
{ |
|
struct i2c_client *client = file->private_data; |
|
u8 buffer[I2C_SMBUS_BLOCK_MAX]; |
|
char str[(I2C_SMBUS_BLOCK_MAX * 2) + 2]; |
|
char *res; |
|
int rc; |
|
|
|
rc = ucd9000_get_mfr_status(client, buffer); |
|
if (rc < 0) |
|
return rc; |
|
|
|
res = bin2hex(str, buffer, min(rc, I2C_SMBUS_BLOCK_MAX)); |
|
*res++ = '\n'; |
|
*res = 0; |
|
|
|
return simple_read_from_buffer(buf, count, ppos, str, res - str); |
|
} |
|
|
|
static const struct file_operations ucd9000_debugfs_show_mfr_status_fops = { |
|
.llseek = noop_llseek, |
|
.read = ucd9000_debugfs_read_mfr_status, |
|
.open = simple_open, |
|
}; |
|
|
|
static int ucd9000_init_debugfs(struct i2c_client *client, |
|
const struct i2c_device_id *mid, |
|
struct ucd9000_data *data) |
|
{ |
|
struct dentry *debugfs; |
|
struct ucd9000_debugfs_entry *entries; |
|
int i, gpi_count; |
|
char name[UCD9000_DEBUGFS_NAME_LEN]; |
|
|
|
debugfs = pmbus_get_debugfs_dir(client); |
|
if (!debugfs) |
|
return -ENOENT; |
|
|
|
data->debugfs = debugfs_create_dir(client->name, debugfs); |
|
if (!data->debugfs) |
|
return -ENOENT; |
|
|
|
/* |
|
* Of the chips this driver supports, only the UCD9090, UCD90160, |
|
* UCD90320, and UCD90910 report GPI faults in their MFR_STATUS |
|
* register, so only create the GPI fault debugfs attributes for those |
|
* chips. |
|
*/ |
|
if (mid->driver_data == ucd9090 || mid->driver_data == ucd90160 || |
|
mid->driver_data == ucd90320 || mid->driver_data == ucd90910) { |
|
gpi_count = mid->driver_data == ucd90320 ? UCD90320_GPI_COUNT |
|
: UCD9000_GPI_COUNT; |
|
entries = devm_kcalloc(&client->dev, |
|
gpi_count, sizeof(*entries), |
|
GFP_KERNEL); |
|
if (!entries) |
|
return -ENOMEM; |
|
|
|
for (i = 0; i < gpi_count; i++) { |
|
entries[i].client = client; |
|
entries[i].index = i; |
|
scnprintf(name, UCD9000_DEBUGFS_NAME_LEN, |
|
"gpi%d_alarm", i + 1); |
|
debugfs_create_file(name, 0444, data->debugfs, |
|
&entries[i], |
|
&ucd9000_debugfs_mfr_status_bit); |
|
} |
|
} |
|
|
|
scnprintf(name, UCD9000_DEBUGFS_NAME_LEN, "mfr_status"); |
|
debugfs_create_file(name, 0444, data->debugfs, client, |
|
&ucd9000_debugfs_show_mfr_status_fops); |
|
|
|
return 0; |
|
} |
|
#else |
|
static int ucd9000_init_debugfs(struct i2c_client *client, |
|
const struct i2c_device_id *mid, |
|
struct ucd9000_data *data) |
|
{ |
|
return 0; |
|
} |
|
#endif /* CONFIG_DEBUG_FS */ |
|
|
|
static int ucd9000_probe(struct i2c_client *client) |
|
{ |
|
u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1]; |
|
struct ucd9000_data *data; |
|
struct pmbus_driver_info *info; |
|
const struct i2c_device_id *mid; |
|
enum chips chip; |
|
int i, ret; |
|
|
|
if (!i2c_check_functionality(client->adapter, |
|
I2C_FUNC_SMBUS_BYTE_DATA | |
|
I2C_FUNC_SMBUS_BLOCK_DATA)) |
|
return -ENODEV; |
|
|
|
ret = i2c_smbus_read_block_data(client, UCD9000_DEVICE_ID, |
|
block_buffer); |
|
if (ret < 0) { |
|
dev_err(&client->dev, "Failed to read device ID\n"); |
|
return ret; |
|
} |
|
block_buffer[ret] = '\0'; |
|
dev_info(&client->dev, "Device ID %s\n", block_buffer); |
|
|
|
for (mid = ucd9000_id; mid->name[0]; mid++) { |
|
if (!strncasecmp(mid->name, block_buffer, strlen(mid->name))) |
|
break; |
|
} |
|
if (!mid->name[0]) { |
|
dev_err(&client->dev, "Unsupported device\n"); |
|
return -ENODEV; |
|
} |
|
|
|
if (client->dev.of_node) |
|
chip = (enum chips)of_device_get_match_data(&client->dev); |
|
else |
|
chip = mid->driver_data; |
|
|
|
if (chip != ucd9000 && strcmp(client->name, mid->name) != 0) |
|
dev_notice(&client->dev, |
|
"Device mismatch: Configured %s, detected %s\n", |
|
client->name, mid->name); |
|
|
|
data = devm_kzalloc(&client->dev, sizeof(struct ucd9000_data), |
|
GFP_KERNEL); |
|
if (!data) |
|
return -ENOMEM; |
|
info = &data->info; |
|
|
|
ret = i2c_smbus_read_byte_data(client, UCD9000_NUM_PAGES); |
|
if (ret < 0) { |
|
dev_err(&client->dev, |
|
"Failed to read number of active pages\n"); |
|
return ret; |
|
} |
|
info->pages = ret; |
|
if (!info->pages) { |
|
dev_err(&client->dev, "No pages configured\n"); |
|
return -ENODEV; |
|
} |
|
|
|
/* The internal temperature sensor is always active */ |
|
info->func[0] = PMBUS_HAVE_TEMP; |
|
|
|
/* Everything else is configurable */ |
|
ret = i2c_smbus_read_block_data(client, UCD9000_MONITOR_CONFIG, |
|
block_buffer); |
|
if (ret <= 0) { |
|
dev_err(&client->dev, "Failed to read configuration data\n"); |
|
return -ENODEV; |
|
} |
|
for (i = 0; i < ret; i++) { |
|
int page = UCD9000_MON_PAGE(block_buffer[i]); |
|
|
|
if (page >= info->pages) |
|
continue; |
|
|
|
switch (UCD9000_MON_TYPE(block_buffer[i])) { |
|
case UCD9000_MON_VOLTAGE: |
|
case UCD9000_MON_VOLTAGE_HW: |
|
info->func[page] |= PMBUS_HAVE_VOUT |
|
| PMBUS_HAVE_STATUS_VOUT; |
|
break; |
|
case UCD9000_MON_TEMPERATURE: |
|
info->func[page] |= PMBUS_HAVE_TEMP2 |
|
| PMBUS_HAVE_STATUS_TEMP; |
|
break; |
|
case UCD9000_MON_CURRENT: |
|
info->func[page] |= PMBUS_HAVE_IOUT |
|
| PMBUS_HAVE_STATUS_IOUT; |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
|
|
/* Fan configuration */ |
|
if (mid->driver_data == ucd90124) { |
|
for (i = 0; i < UCD9000_NUM_FAN; i++) { |
|
i2c_smbus_write_byte_data(client, |
|
UCD9000_FAN_CONFIG_INDEX, i); |
|
ret = i2c_smbus_read_block_data(client, |
|
UCD9000_FAN_CONFIG, |
|
data->fan_data[i]); |
|
if (ret < 0) |
|
return ret; |
|
} |
|
i2c_smbus_write_byte_data(client, UCD9000_FAN_CONFIG_INDEX, 0); |
|
|
|
info->read_byte_data = ucd9000_read_byte_data; |
|
info->func[0] |= PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12 |
|
| PMBUS_HAVE_FAN34 | PMBUS_HAVE_STATUS_FAN34; |
|
} |
|
|
|
ucd9000_probe_gpio(client, mid, data); |
|
|
|
ret = pmbus_do_probe(client, info); |
|
if (ret) |
|
return ret; |
|
|
|
ret = ucd9000_init_debugfs(client, mid, data); |
|
if (ret) |
|
dev_warn(&client->dev, "Failed to register debugfs: %d\n", |
|
ret); |
|
|
|
return 0; |
|
} |
|
|
|
/* This is the driver that will be inserted */ |
|
static struct i2c_driver ucd9000_driver = { |
|
.driver = { |
|
.name = "ucd9000", |
|
.of_match_table = of_match_ptr(ucd9000_of_match), |
|
}, |
|
.probe_new = ucd9000_probe, |
|
.id_table = ucd9000_id, |
|
}; |
|
|
|
module_i2c_driver(ucd9000_driver); |
|
|
|
MODULE_AUTHOR("Guenter Roeck"); |
|
MODULE_DESCRIPTION("PMBus driver for TI UCD90xxx"); |
|
MODULE_LICENSE("GPL"); |
|
MODULE_IMPORT_NS(PMBUS);
|
|
|