linux/drivers/platform/x86/silicom-platform.c

// SPDX-License-Identifier: GPL-2.0+
//
// silicom-platform.c - Silicom MEC170x platform driver
//
// Copyright (C) 2023 Henry Shi <[email protected]>
#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
#define MEC_EFUSE_LSB_ADDR
#define MEC_GPIO_IN_POS
#define MEC_IO_BASE
#define MEC_IO_LEN
#define IO_REG_BANK
#define DEFAULT_CHAN_LO
#define DEFAULT_CHAN_HI
#define DEFAULT_CHAN_LO_T
#define MEC_ADDR
#define EC_ADDR_LSB
#define SILICOM_MEC_MAGIC

#define MEC_PORT_CHANNEL_MASK
#define MEC_PORT_DWORD_OFFSET
#define MEC_DATA_OFFSET_MASK
#define MEC_PORT_OFFSET_MASK

#define MEC_TEMP_LOC
#define MEC_VERSION_LOC
#define MEC_VERSION_MAJOR
#define MEC_VERSION_MINOR

#define EC_ADDR_MSB
#define MEC_DATA_OFFSET(offset)

#define OFFSET_BIT_TO_CHANNEL(off, bit)
#define CHANNEL_TO_OFFSET(chan)

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[] =;

struct silicom_platform_info {};

static const char * const plat_0222_gpio_names[] =;

static u8 plat_0222_gpio_channels[] =;

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)
{}

static enum led_brightness silicom_mec_led_get(int channel)
{}

static void silicom_mec_port_set(int channel, int on)
{}

static enum led_brightness silicom_mec_led_mc_brightness_get(struct led_classdev *led_cdev)
{}

static void silicom_mec_led_mc_brightness_set(struct led_classdev *led_cdev,
					      enum led_brightness brightness)
{}

static int silicom_gpio_get_direction(struct gpio_chip *gc,
				      unsigned int offset)
{}

static int silicom_gpio_direction_input(struct gpio_chip *gc,
					unsigned int offset)
{}

static void silicom_gpio_set(struct gpio_chip *gc,
			     unsigned int offset,
			     int value)
{}

static int silicom_gpio_direction_output(struct gpio_chip *gc,
					 unsigned int offset,
					 int value)
{}

static int silicom_gpio_get(struct gpio_chip *gc, unsigned int offset)
{}

static struct mc_subled plat_0222_wan_mc_subled_info[] __initdata =;

static struct mc_subled plat_0222_sys_mc_subled_info[] __initdata =;

static struct mc_subled plat_0222_stat1_mc_subled_info[] __initdata =;

static struct mc_subled plat_0222_stat2_mc_subled_info[] __initdata =;

static struct mc_subled plat_0222_stat3_mc_subled_info[] __initdata =;

static struct led_classdev_mc plat_0222_mc_led_info[] __initdata =;

static struct gpio_chip silicom_gpio_chip =;

static struct silicom_platform_info silicom_plat_0222_cordoba_info __initdata =;

static struct mc_subled cordoba_fp_left_mc_subled_info[] __initdata =;

static struct mc_subled cordoba_fp_center_mc_subled_info[] __initdata =;

static struct mc_subled cordoba_fp_right_mc_subled_info[] __initdata =;

static struct led_classdev_mc cordoba_mc_led_info[] __initdata =;

static struct silicom_platform_info silicom_generic_cordoba_info __initdata =;

/*
 * sysfs interface
 */
static ssize_t efuse_status_show(struct device *dev,
				 struct device_attribute *attr,
				 char *buf)
{}
static DEVICE_ATTR_RO(efuse_status);

static ssize_t uc_version_show(struct device *dev,
			       struct device_attribute *attr,
			       char *buf)
{}
static DEVICE_ATTR_RO(uc_version);

static ssize_t power_cycle_show(struct device *dev,
				struct device_attribute *attr,
				char *buf)
{}

static void powercycle_uc(void)
{}

static ssize_t power_cycle_store(struct device *dev,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{}
static DEVICE_ATTR_RW(power_cycle);

static struct attribute *silicom_attrs[] =;
ATTRIBUTE_GROUPS();

static struct platform_driver silicom_platform_driver =;

static int __init silicom_mc_leds_register(struct device *dev,
					   const struct led_classdev_mc *mc_leds)
{}

static u32 rpm_get(void)
{}

static u32 temp_get(void)
{}

static umode_t silicom_fan_control_fan_is_visible(const u32 attr)
{}

static umode_t silicom_fan_control_temp_is_visible(const u32 attr)
{}

static int silicom_fan_control_read_fan(struct device *dev, u32 attr, long *val)
{}

static int silicom_fan_control_read_temp(struct device *dev, u32 attr, long *val)
{}

static umode_t silicom_fan_control_is_visible(const void *data,
					      enum hwmon_sensor_types type,
					      u32 attr, int channel)
{}

static int silicom_fan_control_read(struct device *dev,
				    enum hwmon_sensor_types type,
				    u32 attr, int channel,
				    long *val)
{}

static int silicom_fan_control_read_labels(struct device *dev,
					   enum hwmon_sensor_types type,
					   u32 attr, int channel,
					   const char **str)
{}

static const struct hwmon_ops silicom_fan_control_hwmon_ops =;

static const struct hwmon_chip_info silicom_chip_info =;

static int __init silicom_platform_probe(struct platform_device *device)
{}

static int __init silicom_platform_info_init(const struct dmi_system_id *id)
{}

static const struct dmi_system_id silicom_dmi_ids[] __initconst =;
MODULE_DEVICE_TABLE(dmi, silicom_dmi_ids);

static int __init silicom_platform_init(void)
{}

static void __exit silicom_platform_exit(void)
{}

module_init();
module_exit(silicom_platform_exit);

MODULE_LICENSE();
MODULE_AUTHOR();
MODULE_DESCRIPTION();