| // 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"); |
