| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Henry Shi | 4160 | 99.95% | 1 | 33.33% |
| Dan Carpenter | 1 | 0.02% | 1 | 33.33% |
| Colin Ian King | 1 | 0.02% | 1 | 33.33% |
| Total | 4162 | 3 |
// SPDX-License-Identifier: GPL-2.0+ // // silicom-platform.c - Silicom MEC170x platform driver // // Copyright (C) 2023 Henry Shi <henrys@silicom-usa.com> #include <linux/bitfield.h> #include <linux/bits.h> #include <linux/dmi.h> #include <linux/hwmon.h> #include <linux/init.h> #include <linux/ioport.h> #include <linux/io.h> #include <linux/kernel.h> #include <linux/kobject.h> #include <linux/led-class-multicolor.h> #include <linux/module.h> #include <linux/mutex.h> #include <linux/platform_device.h> #include <linux/string.h> #include <linux/sysfs.h> #include <linux/units.h> #include <linux/gpio/driver.h> #define MEC_POWER_CYCLE_ADDR 0x24 #define MEC_EFUSE_LSB_ADDR 0x28 #define MEC_GPIO_IN_POS 0x08 #define MEC_IO_BASE 0x0800 #define MEC_IO_LEN 0x8 #define IO_REG_BANK 0x0 #define DEFAULT_CHAN_LO 0 #define DEFAULT_CHAN_HI 0 #define DEFAULT_CHAN_LO_T 0xc #define MEC_ADDR (MEC_IO_BASE + 0x02) #define EC_ADDR_LSB MEC_ADDR #define SILICOM_MEC_MAGIC 0x5a #define MEC_PORT_CHANNEL_MASK GENMASK(2, 0) #define MEC_PORT_DWORD_OFFSET GENMASK(31, 3) #define MEC_DATA_OFFSET_MASK GENMASK(1, 0) #define MEC_PORT_OFFSET_MASK GENMASK(7, 2) #define MEC_TEMP_LOC GENMASK(31, 16) #define MEC_VERSION_LOC GENMASK(15, 8) #define MEC_VERSION_MAJOR GENMASK(15, 14) #define MEC_VERSION_MINOR GENMASK(13, 8) #define EC_ADDR_MSB (MEC_IO_BASE + 0x3) #define MEC_DATA_OFFSET(offset) (MEC_IO_BASE + 0x04 + (offset)) #define OFFSET_BIT_TO_CHANNEL(off, bit) ((((off) + 0x014) << 3) | (bit)) #define CHANNEL_TO_OFFSET(chan) (((chan) >> 3) - 0x14) static DEFINE_MUTEX(mec_io_mutex); static unsigned int efuse_status; static unsigned int mec_uc_version; static unsigned int power_cycle; static const struct hwmon_channel_info *silicom_fan_control_info[] = { HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT | HWMON_F_LABEL), HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT | HWMON_T_LABEL), NULL }; struct silicom_platform_info { int io_base; int io_len; struct led_classdev_mc *led_info; struct gpio_chip *gpiochip; u8 *gpio_channels; u16 ngpio; }; static const char * const plat_0222_gpio_names[] = { "AUTOM0_SFP_TX_FAULT", "SLOT2_LED_OUT", "SIM_M2_SLOT2_B_DET", "SIM_M2_SLOT2_A_DET", "SLOT1_LED_OUT", "SIM_M2_SLOT1_B_DET", "SIM_M2_SLOT1_A_DET", "SLOT0_LED_OUT", "WAN_SFP0_RX_LOS", "WAN_SFP0_PRSNT_N", "WAN_SFP0_TX_FAULT", "AUTOM1_SFP_RX_LOS", "AUTOM1_SFP_PRSNT_N", "AUTOM1_SFP_TX_FAULT", "AUTOM0_SFP_RX_LOS", "AUTOM0_SFP_PRSNT_N", "WAN_SFP1_RX_LOS", "WAN_SFP1_PRSNT_N", "WAN_SFP1_TX_FAULT", "SIM_M2_SLOT1_MUX_SEL", "W_DISABLE_M2_SLOT1_N", "W_DISABLE_MPCIE_SLOT0_N", "W_DISABLE_M2_SLOT0_N", "BT_COMMAND_MODE", "WAN_SFP1_TX_DISABLE", "WAN_SFP0_TX_DISABLE", "AUTOM1_SFP_TX_DISABLE", "AUTOM0_SFP_TX_DISABLE", "SIM_M2_SLOT2_MUX_SEL", "W_DISABLE_M2_SLOT2_N", "RST_CTL_M2_SLOT_1_N", "RST_CTL_M2_SLOT_2_N", "PM_USB_PWR_EN_BOT", "PM_USB_PWR_EN_TOP", }; static u8 plat_0222_gpio_channels[] = { OFFSET_BIT_TO_CHANNEL(0x00, 0), OFFSET_BIT_TO_CHANNEL(0x00, 1), OFFSET_BIT_TO_CHANNEL(0x00, 2), OFFSET_BIT_TO_CHANNEL(0x00, 3), OFFSET_BIT_TO_CHANNEL(0x00, 4), OFFSET_BIT_TO_CHANNEL(0x00, 5), OFFSET_BIT_TO_CHANNEL(0x00, 6), OFFSET_BIT_TO_CHANNEL(0x00, 7), OFFSET_BIT_TO_CHANNEL(0x01, 0), OFFSET_BIT_TO_CHANNEL(0x01, 1), OFFSET_BIT_TO_CHANNEL(0x01, 2), OFFSET_BIT_TO_CHANNEL(0x01, 3), OFFSET_BIT_TO_CHANNEL(0x01, 4), OFFSET_BIT_TO_CHANNEL(0x01, 5), OFFSET_BIT_TO_CHANNEL(0x01, 6), OFFSET_BIT_TO_CHANNEL(0x01, 7), OFFSET_BIT_TO_CHANNEL(0x02, 0), OFFSET_BIT_TO_CHANNEL(0x02, 1), OFFSET_BIT_TO_CHANNEL(0x02, 2), OFFSET_BIT_TO_CHANNEL(0x09, 0), OFFSET_BIT_TO_CHANNEL(0x09, 1), OFFSET_BIT_TO_CHANNEL(0x09, 2), OFFSET_BIT_TO_CHANNEL(0x09, 3), OFFSET_BIT_TO_CHANNEL(0x0a, 0), OFFSET_BIT_TO_CHANNEL(0x0a, 1), OFFSET_BIT_TO_CHANNEL(0x0a, 2), OFFSET_BIT_TO_CHANNEL(0x0a, 3), OFFSET_BIT_TO_CHANNEL(0x0a, 4), OFFSET_BIT_TO_CHANNEL(0x0a, 5), OFFSET_BIT_TO_CHANNEL(0x0a, 6), OFFSET_BIT_TO_CHANNEL(0x0b, 0), OFFSET_BIT_TO_CHANNEL(0x0b, 1), OFFSET_BIT_TO_CHANNEL(0x0b, 2), OFFSET_BIT_TO_CHANNEL(0x0b, 3), }; static struct platform_device *silicom_platform_dev; static struct led_classdev_mc *silicom_led_info __initdata; static struct gpio_chip *silicom_gpiochip __initdata; static u8 *silicom_gpio_channels __initdata; static int silicom_mec_port_get(unsigned int offset) { unsigned short mec_data_addr; unsigned short mec_port_addr; u8 reg; mec_data_addr = FIELD_GET(MEC_PORT_DWORD_OFFSET, offset) & MEC_DATA_OFFSET_MASK; mec_port_addr = FIELD_GET(MEC_PORT_DWORD_OFFSET, offset) & MEC_PORT_OFFSET_MASK; mutex_lock(&mec_io_mutex); outb(mec_port_addr, MEC_ADDR); reg = inb(MEC_DATA_OFFSET(mec_data_addr)); mutex_unlock(&mec_io_mutex); return (reg >> (offset & MEC_PORT_CHANNEL_MASK)) & 0x01; } static enum led_brightness silicom_mec_led_get(int channel) { /* Outputs are active low */ return silicom_mec_port_get(channel) ? LED_OFF : LED_ON; } static void silicom_mec_port_set(int channel, int on) { unsigned short mec_data_addr; unsigned short mec_port_addr; u8 reg; mec_data_addr = FIELD_GET(MEC_PORT_DWORD_OFFSET, channel) & MEC_DATA_OFFSET_MASK; mec_port_addr = FIELD_GET(MEC_PORT_DWORD_OFFSET, channel) & MEC_PORT_OFFSET_MASK; mutex_lock(&mec_io_mutex); outb(mec_port_addr, MEC_ADDR); reg = inb(MEC_DATA_OFFSET(mec_data_addr)); /* Outputs are active low, so clear the bit for on, or set it for off */ if (on) reg &= ~(1 << (channel & MEC_PORT_CHANNEL_MASK)); else reg |= 1 << (channel & MEC_PORT_CHANNEL_MASK); outb(reg, MEC_DATA_OFFSET(mec_data_addr)); mutex_unlock(&mec_io_mutex); } static enum led_brightness silicom_mec_led_mc_brightness_get(struct led_classdev *led_cdev) { struct led_classdev_mc *mc_cdev = lcdev_to_mccdev(led_cdev); enum led_brightness brightness = LED_OFF; int i; for (i = 0; i < mc_cdev->num_colors; i++) { mc_cdev->subled_info[i].brightness = silicom_mec_led_get(mc_cdev->subled_info[i].channel); /* Mark the overall brightness as LED_ON if any of the subleds are on */ if (mc_cdev->subled_info[i].brightness != LED_OFF) brightness = LED_ON; } return brightness; } static void silicom_mec_led_mc_brightness_set(struct led_classdev *led_cdev, enum led_brightness brightness) { struct led_classdev_mc *mc_cdev = lcdev_to_mccdev(led_cdev); int i; led_mc_calc_color_components(mc_cdev, brightness); for (i = 0; i < mc_cdev->num_colors; i++) { silicom_mec_port_set(mc_cdev->subled_info[i].channel, mc_cdev->subled_info[i].brightness); } } static int silicom_gpio_get_direction(struct gpio_chip *gc, unsigned int offset) { u8 *channels = gpiochip_get_data(gc); /* Input registers have offsets between [0x00, 0x07] */ if (CHANNEL_TO_OFFSET(channels[offset]) < MEC_GPIO_IN_POS) return GPIO_LINE_DIRECTION_IN; return GPIO_LINE_DIRECTION_OUT; } static int silicom_gpio_direction_input(struct gpio_chip *gc, unsigned int offset) { int direction = silicom_gpio_get_direction(gc, offset); return direction == GPIO_LINE_DIRECTION_IN ? 0 : -EINVAL; } static void silicom_gpio_set(struct gpio_chip *gc, unsigned int offset, int value) { int direction = silicom_gpio_get_direction(gc, offset); u8 *channels = gpiochip_get_data(gc); int channel = channels[offset]; if (direction == GPIO_LINE_DIRECTION_IN) return; silicom_mec_port_set(channel, !value); } static int silicom_gpio_direction_output(struct gpio_chip *gc, unsigned int offset, int value) { int direction = silicom_gpio_get_direction(gc, offset); if (direction == GPIO_LINE_DIRECTION_IN) return -EINVAL; silicom_gpio_set(gc, offset, value); return 0; } static int silicom_gpio_get(struct gpio_chip *gc, unsigned int offset) { u8 *channels = gpiochip_get_data(gc); int channel = channels[offset]; return silicom_mec_port_get(channel); } static struct mc_subled plat_0222_wan_mc_subled_info[] __initdata = { { .color_index = LED_COLOR_ID_WHITE, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0c, 7), }, { .color_index = LED_COLOR_ID_YELLOW, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0c, 6), }, { .color_index = LED_COLOR_ID_RED, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0c, 5), }, }; static struct mc_subled plat_0222_sys_mc_subled_info[] __initdata = { { .color_index = LED_COLOR_ID_WHITE, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0c, 4), }, { .color_index = LED_COLOR_ID_AMBER, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0c, 3), }, { .color_index = LED_COLOR_ID_RED, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0c, 2), }, }; static struct mc_subled plat_0222_stat1_mc_subled_info[] __initdata = { { .color_index = LED_COLOR_ID_RED, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0c, 1), }, { .color_index = LED_COLOR_ID_GREEN, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0c, 0), }, { .color_index = LED_COLOR_ID_BLUE, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0d, 7), }, { .color_index = LED_COLOR_ID_YELLOW, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0d, 6), }, }; static struct mc_subled plat_0222_stat2_mc_subled_info[] __initdata = { { .color_index = LED_COLOR_ID_RED, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0d, 5), }, { .color_index = LED_COLOR_ID_GREEN, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0d, 4), }, { .color_index = LED_COLOR_ID_BLUE, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0d, 3), }, { .color_index = LED_COLOR_ID_YELLOW, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0d, 2), }, }; static struct mc_subled plat_0222_stat3_mc_subled_info[] __initdata = { { .color_index = LED_COLOR_ID_RED, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0d, 1), }, { .color_index = LED_COLOR_ID_GREEN, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0d, 0), }, { .color_index = LED_COLOR_ID_BLUE, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0e, 1), }, { .color_index = LED_COLOR_ID_YELLOW, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x0e, 0), }, }; static struct led_classdev_mc plat_0222_mc_led_info[] __initdata = { { .led_cdev = { .name = "platled::wan", .brightness = 0, .max_brightness = 1, .brightness_set = silicom_mec_led_mc_brightness_set, .brightness_get = silicom_mec_led_mc_brightness_get, }, .num_colors = ARRAY_SIZE(plat_0222_wan_mc_subled_info), .subled_info = plat_0222_wan_mc_subled_info, }, { .led_cdev = { .name = "platled::sys", .brightness = 0, .max_brightness = 1, .brightness_set = silicom_mec_led_mc_brightness_set, .brightness_get = silicom_mec_led_mc_brightness_get, }, .num_colors = ARRAY_SIZE(plat_0222_sys_mc_subled_info), .subled_info = plat_0222_sys_mc_subled_info, }, { .led_cdev = { .name = "platled::stat1", .brightness = 0, .max_brightness = 1, .brightness_set = silicom_mec_led_mc_brightness_set, .brightness_get = silicom_mec_led_mc_brightness_get, }, .num_colors = ARRAY_SIZE(plat_0222_stat1_mc_subled_info), .subled_info = plat_0222_stat1_mc_subled_info, }, { .led_cdev = { .name = "platled::stat2", .brightness = 0, .max_brightness = 1, .brightness_set = silicom_mec_led_mc_brightness_set, .brightness_get = silicom_mec_led_mc_brightness_get, }, .num_colors = ARRAY_SIZE(plat_0222_stat2_mc_subled_info), .subled_info = plat_0222_stat2_mc_subled_info, }, { .led_cdev = { .name = "platled::stat3", .brightness = 0, .max_brightness = 1, .brightness_set = silicom_mec_led_mc_brightness_set, .brightness_get = silicom_mec_led_mc_brightness_get, }, .num_colors = ARRAY_SIZE(plat_0222_stat3_mc_subled_info), .subled_info = plat_0222_stat3_mc_subled_info, }, { }, }; static struct gpio_chip silicom_gpio_chip = { .label = "silicom-gpio", .get_direction = silicom_gpio_get_direction, .direction_input = silicom_gpio_direction_input, .direction_output = silicom_gpio_direction_output, .get = silicom_gpio_get, .set = silicom_gpio_set, .base = -1, .ngpio = ARRAY_SIZE(plat_0222_gpio_channels), .names = plat_0222_gpio_names, /* * We're using a mutex to protect the indirect access, so we can sleep * if the lock blocks */ .can_sleep = true, }; static struct silicom_platform_info silicom_plat_0222_cordoba_info __initdata = { .io_base = MEC_IO_BASE, .io_len = MEC_IO_LEN, .led_info = plat_0222_mc_led_info, .gpiochip = &silicom_gpio_chip, .gpio_channels = plat_0222_gpio_channels, /* * The original generic cordoba does not have the last 4 outputs of the * plat_0222 variant, the rest are the same, so use the same longer list, * but ignore the last entries here */ .ngpio = ARRAY_SIZE(plat_0222_gpio_channels), }; static struct mc_subled cordoba_fp_left_mc_subled_info[] __initdata = { { .color_index = LED_COLOR_ID_RED, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x08, 6), }, { .color_index = LED_COLOR_ID_GREEN, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x08, 5), }, { .color_index = LED_COLOR_ID_BLUE, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x09, 7), }, { .color_index = LED_COLOR_ID_AMBER, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x09, 4), }, }; static struct mc_subled cordoba_fp_center_mc_subled_info[] __initdata = { { .color_index = LED_COLOR_ID_RED, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x08, 7), }, { .color_index = LED_COLOR_ID_GREEN, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x08, 4), }, { .color_index = LED_COLOR_ID_BLUE, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x08, 3), }, { .color_index = LED_COLOR_ID_AMBER, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x09, 6), }, }; static struct mc_subled cordoba_fp_right_mc_subled_info[] __initdata = { { .color_index = LED_COLOR_ID_RED, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x08, 2), }, { .color_index = LED_COLOR_ID_GREEN, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x08, 1), }, { .color_index = LED_COLOR_ID_BLUE, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x08, 0), }, { .color_index = LED_COLOR_ID_AMBER, .brightness = 1, .intensity = 0, .channel = OFFSET_BIT_TO_CHANNEL(0x09, 5), }, }; static struct led_classdev_mc cordoba_mc_led_info[] __initdata = { { .led_cdev = { .name = "platled::fp_left", .brightness = 0, .max_brightness = 1, .brightness_set = silicom_mec_led_mc_brightness_set, .brightness_get = silicom_mec_led_mc_brightness_get, }, .num_colors = ARRAY_SIZE(cordoba_fp_left_mc_subled_info), .subled_info = cordoba_fp_left_mc_subled_info, }, { .led_cdev = { .name = "platled::fp_center", .brightness = 0, .max_brightness = 1, .brightness_set = silicom_mec_led_mc_brightness_set, .brightness_get = silicom_mec_led_mc_brightness_get, }, .num_colors = ARRAY_SIZE(cordoba_fp_center_mc_subled_info), .subled_info = cordoba_fp_center_mc_subled_info, }, { .led_cdev = { .name = "platled::fp_right", .brightness = 0, .max_brightness = 1, .brightness_set = silicom_mec_led_mc_brightness_set, .brightness_get = silicom_mec_led_mc_brightness_get, }, .num_colors = ARRAY_SIZE(cordoba_fp_right_mc_subled_info), .subled_info = cordoba_fp_right_mc_subled_info, }, { }, }; static struct silicom_platform_info silicom_generic_cordoba_info __initdata = { .io_base = MEC_IO_BASE, .io_len = MEC_IO_LEN, .led_info = cordoba_mc_led_info, .gpiochip = &silicom_gpio_chip, .gpio_channels = plat_0222_gpio_channels, .ngpio = ARRAY_SIZE(plat_0222_gpio_channels), }; /* * sysfs interface */ static ssize_t efuse_status_show(struct device *dev, struct device_attribute *attr, char *buf) { u32 reg; mutex_lock(&mec_io_mutex); /* Select memory region */ outb(IO_REG_BANK, EC_ADDR_MSB); outb(MEC_EFUSE_LSB_ADDR, EC_ADDR_LSB); /* Get current data from the address */ reg = inl(MEC_DATA_OFFSET(DEFAULT_CHAN_LO)); mutex_unlock(&mec_io_mutex); efuse_status = reg & 0x1; return sysfs_emit(buf, "%u\n", efuse_status); } static DEVICE_ATTR_RO(efuse_status); static ssize_t uc_version_show(struct device *dev, struct device_attribute *attr, char *buf) { int uc_version; u32 reg; mutex_lock(&mec_io_mutex); outb(IO_REG_BANK, EC_ADDR_MSB); outb(DEFAULT_CHAN_LO, EC_ADDR_LSB); reg = inl(MEC_DATA_OFFSET(DEFAULT_CHAN_LO)); mutex_unlock(&mec_io_mutex); uc_version = FIELD_GET(MEC_VERSION_LOC, reg); if (uc_version >= 192) return -EINVAL; uc_version = FIELD_GET(MEC_VERSION_MAJOR, reg) * 100 + FIELD_GET(MEC_VERSION_MINOR, reg); mec_uc_version = uc_version; return sysfs_emit(buf, "%u\n", mec_uc_version); } static DEVICE_ATTR_RO(uc_version); static ssize_t power_cycle_show(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_emit(buf, "%u\n", power_cycle); } static void powercycle_uc(void) { /* Select memory region */ outb(IO_REG_BANK, EC_ADDR_MSB); outb(MEC_POWER_CYCLE_ADDR, EC_ADDR_LSB); /* Set to 1 for current data from the address */ outb(1, MEC_DATA_OFFSET(DEFAULT_CHAN_LO)); } static ssize_t power_cycle_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int rc; unsigned int power_cycle_cmd; rc = kstrtou32(buf, 0, &power_cycle_cmd); if (rc) return -EINVAL; if (power_cycle_cmd > 0) { mutex_lock(&mec_io_mutex); power_cycle = power_cycle_cmd; powercycle_uc(); mutex_unlock(&mec_io_mutex); } return count; } static DEVICE_ATTR_RW(power_cycle); static struct attribute *silicom_attrs[] = { &dev_attr_efuse_status.attr, &dev_attr_uc_version.attr, &dev_attr_power_cycle.attr, NULL, }; ATTRIBUTE_GROUPS(silicom); static struct platform_driver silicom_platform_driver = { .driver = { .name = "silicom-platform", .dev_groups = silicom_groups, }, }; static int __init silicom_mc_leds_register(struct device *dev, const struct led_classdev_mc *mc_leds) { int size = sizeof(struct mc_subled); struct led_classdev_mc *led; int i, err; for (i = 0; mc_leds[i].led_cdev.name; i++) { led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL); if (!led) return -ENOMEM; memcpy(led, &mc_leds[i], sizeof(*led)); led->subled_info = devm_kzalloc(dev, led->num_colors * size, GFP_KERNEL); if (!led->subled_info) return -ENOMEM; memcpy(led->subled_info, mc_leds[i].subled_info, led->num_colors * size); err = devm_led_classdev_multicolor_register(dev, led); if (err) return err; } return 0; } static u32 rpm_get(void) { u32 reg; mutex_lock(&mec_io_mutex); /* Select memory region */ outb(IO_REG_BANK, EC_ADDR_MSB); outb(DEFAULT_CHAN_LO_T, EC_ADDR_LSB); reg = inw(MEC_DATA_OFFSET(DEFAULT_CHAN_LO)); mutex_unlock(&mec_io_mutex); return reg; } static u32 temp_get(void) { u32 reg; mutex_lock(&mec_io_mutex); /* Select memory region */ outb(IO_REG_BANK, EC_ADDR_MSB); outb(DEFAULT_CHAN_LO_T, EC_ADDR_LSB); reg = inl(MEC_DATA_OFFSET(DEFAULT_CHAN_LO)); mutex_unlock(&mec_io_mutex); return FIELD_GET(MEC_TEMP_LOC, reg) * 100; } static umode_t silicom_fan_control_fan_is_visible(const u32 attr) { switch (attr) { case hwmon_fan_input: case hwmon_fan_label: return 0444; default: return 0; } } static umode_t silicom_fan_control_temp_is_visible(const u32 attr) { switch (attr) { case hwmon_temp_input: case hwmon_temp_label: return 0444; default: return 0; } } static int silicom_fan_control_read_fan(struct device *dev, u32 attr, long *val) { switch (attr) { case hwmon_fan_input: *val = rpm_get(); return 0; default: return -EOPNOTSUPP; } } static int silicom_fan_control_read_temp(struct device *dev, u32 attr, long *val) { switch (attr) { case hwmon_temp_input: *val = temp_get(); return 0; default: return -EOPNOTSUPP; } } static umode_t silicom_fan_control_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr, int channel) { switch (type) { case hwmon_fan: return silicom_fan_control_fan_is_visible(attr); case hwmon_temp: return silicom_fan_control_temp_is_visible(attr); default: return 0; } } static int silicom_fan_control_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, long *val) { switch (type) { case hwmon_fan: return silicom_fan_control_read_fan(dev, attr, val); case hwmon_temp: return silicom_fan_control_read_temp(dev, attr, val); default: return -EOPNOTSUPP; } } static int silicom_fan_control_read_labels(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, const char **str) { switch (type) { case hwmon_fan: *str = "Silicom_platform: Fan Speed"; return 0; case hwmon_temp: *str = "Silicom_platform: Thermostat Sensor"; return 0; default: return -EOPNOTSUPP; } } static const struct hwmon_ops silicom_fan_control_hwmon_ops = { .is_visible = silicom_fan_control_is_visible, .read = silicom_fan_control_read, .read_string = silicom_fan_control_read_labels, }; static const struct hwmon_chip_info silicom_chip_info = { .ops = &silicom_fan_control_hwmon_ops, .info = silicom_fan_control_info, }; static int __init silicom_platform_probe(struct platform_device *device) { struct device *hwmon_dev; u8 magic, ver; int err; if (!devm_request_region(&device->dev, MEC_IO_BASE, MEC_IO_LEN, "mec")) { dev_err(&device->dev, "couldn't reserve MEC io ports\n"); return -EBUSY; } /* Sanity check magic number read for EC */ outb(IO_REG_BANK, MEC_ADDR); magic = inb(MEC_DATA_OFFSET(DEFAULT_CHAN_LO)); ver = inb(MEC_DATA_OFFSET(DEFAULT_CHAN_HI)); dev_dbg(&device->dev, "EC magic 0x%02x, version 0x%02x\n", magic, ver); if (magic != SILICOM_MEC_MAGIC) { dev_err(&device->dev, "Bad EC magic 0x%02x!\n", magic); return -ENODEV; } err = silicom_mc_leds_register(&device->dev, silicom_led_info); if (err) { dev_err(&device->dev, "Failed to register LEDs\n"); return err; } err = devm_gpiochip_add_data(&device->dev, silicom_gpiochip, silicom_gpio_channels); if (err) { dev_err(&device->dev, "Failed to register gpiochip: %d\n", err); return err; } hwmon_dev = devm_hwmon_device_register_with_info(&device->dev, "silicom_fan", NULL, &silicom_chip_info, NULL); err = PTR_ERR_OR_ZERO(hwmon_dev); if (err) { dev_err(&device->dev, "Failed to register hwmon_dev: %d\n", err); return err; } return err; } static int __init silicom_platform_info_init(const struct dmi_system_id *id) { struct silicom_platform_info *info = id->driver_data; silicom_led_info = info->led_info; silicom_gpio_channels = info->gpio_channels; silicom_gpiochip = info->gpiochip; silicom_gpiochip->ngpio = info->ngpio; return 1; } static const struct dmi_system_id silicom_dmi_ids[] __initconst = { { .callback = silicom_platform_info_init, .ident = "Silicom Cordoba (Generic)", .matches = { DMI_MATCH(DMI_BOARD_VENDOR, "Silicom"), DMI_MATCH(DMI_BOARD_NAME, "80300-0214-G"), }, .driver_data = &silicom_generic_cordoba_info, }, { .callback = silicom_platform_info_init, .ident = "Silicom Cordoba (Generic)", .matches = { DMI_MATCH(DMI_BOARD_VENDOR, "Silicom"), DMI_MATCH(DMI_BOARD_NAME, "80500-0214-G"), }, .driver_data = &silicom_generic_cordoba_info, }, { .callback = silicom_platform_info_init, .ident = "Silicom Cordoba (plat_0222)", .matches = { DMI_MATCH(DMI_BOARD_VENDOR, "Silicom"), DMI_MATCH(DMI_BOARD_NAME, "80300-0222-G"), }, .driver_data = &silicom_plat_0222_cordoba_info, }, { }, }; MODULE_DEVICE_TABLE(dmi, silicom_dmi_ids); static int __init silicom_platform_init(void) { if (!dmi_check_system(silicom_dmi_ids)) { pr_err("No DMI match for this platform\n"); return -ENODEV; } silicom_platform_dev = platform_create_bundle(&silicom_platform_driver, silicom_platform_probe, NULL, 0, NULL, 0); return PTR_ERR_OR_ZERO(silicom_platform_dev); } static void __exit silicom_platform_exit(void) { platform_device_unregister(silicom_platform_dev); platform_driver_unregister(&silicom_platform_driver); } module_init(silicom_platform_init); module_exit(silicom_platform_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Henry Shi <henrys@silicom-usa.com>"); MODULE_DESCRIPTION("Platform driver for Silicom network appliances");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1