From 96716c831f258f0753cc7fbf2b432b5d465c6dbf Mon Sep 17 00:00:00 2001 From: Jostar Yang Date: Tue, 10 Apr 2018 18:01:59 +0800 Subject: [PATCH] Add csp9250 onlp code --- .../x86-64/x86-64-accton-csp9250/.gitignore | 3 + .../x86-64/x86-64-accton-csp9250/Makefile | 1 + .../x86-64-accton-csp9250/modules/Makefile | 1 + .../x86-64-accton-csp9250/modules/PKG.yml | 1 + .../modules/builds/.gitignore | 1 + .../modules/builds/Makefile | 6 + .../builds/x86-64-accton-csp9250-cpld.c | 251 +++ .../builds/x86-64-accton-csp9250-fan.c | 488 ++++++ .../builds/x86-64-accton-csp9250-leds.c | 438 ++++++ .../builds/x86-64-accton-csp9250-psu.c | 293 ++++ .../builds/x86-64-accton-csp9250-sfp.c | 1354 +++++++++++++++++ .../x86-64-accton-csp9250/onlp/Makefile | 1 + .../x86-64/x86-64-accton-csp9250/onlp/PKG.yml | 1 + .../onlp/builds/Makefile | 2 + .../onlp/builds/lib/Makefile | 45 + .../onlp/builds/onlpdump/Makefile | 46 + .../onlp/builds/src/.module | 1 + .../onlp/builds/src/Makefile | 9 + .../onlp/builds/src/README | 6 + .../onlp/builds/src/module/auto/make.mk | 9 + .../src/module/auto/x86_64_accton_csp9250.yml | 50 + .../x86_64_accton_csp9250.x | 14 + .../x86_64_accton_csp9250_config.h | 137 ++ .../x86_64_accton_csp9250_dox.h | 26 + .../x86_64_accton_csp9250_porting.h | 107 ++ .../onlp/builds/src/module/make.mk | 10 + .../onlp/builds/src/module/src/Makefile | 9 + .../onlp/builds/src/module/src/debug.c | 45 + .../onlp/builds/src/module/src/fani.c | 423 +++++ .../onlp/builds/src/module/src/ledi.c | 261 ++++ .../onlp/builds/src/module/src/make.mk | 9 + .../onlp/builds/src/module/src/platform_lib.c | 176 +++ .../onlp/builds/src/module/src/platform_lib.h | 85 ++ .../onlp/builds/src/module/src/psui.c | 239 +++ .../onlp/builds/src/module/src/sfpi.c | 353 +++++ .../onlp/builds/src/module/src/sysi.c | 676 ++++++++ .../onlp/builds/src/module/src/thermali.c | 333 ++++ .../module/src/x86_64_accton_csp9250_config.c | 81 + .../module/src/x86_64_accton_csp9250_enums.c | 10 + .../module/src/x86_64_accton_csp9250_int.h | 12 + .../module/src/x86_64_accton_csp9250_log.c | 18 + .../module/src/x86_64_accton_csp9250_log.h | 12 + .../module/src/x86_64_accton_csp9250_module.c | 24 + .../module/src/x86_64_accton_csp9250_ucli.c | 50 + .../onlp/builds/src/x86_64_accton_csp9250.mk | 13 + .../platform-config/Makefile | 1 + .../platform-config/r0/Makefile | 1 + .../platform-config/r0/PKG.yml | 1 + .../r0/src/lib/x86-64-accton-csp9250-r0.yml | 24 + .../x86_64_accton_csp9250_r0/__init__.py | 108 ++ 50 files changed, 6265 insertions(+) create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/.gitignore create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/Makefile create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/Makefile create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/PKG.yml create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/.gitignore create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/Makefile create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-cpld.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-fan.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-leds.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-psu.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-sfp.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/Makefile create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/PKG.yml create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/Makefile create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/lib/Makefile create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/onlpdump/Makefile create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/.module create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/Makefile create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/README create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/auto/make.mk create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/auto/x86_64_accton_csp9250.yml create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250.x create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250_config.h create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250_dox.h create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250_porting.h create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/make.mk create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/Makefile create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/debug.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/fani.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/ledi.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/make.mk create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/platform_lib.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/platform_lib.h create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/psui.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/sfpi.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/sysi.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/thermali.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_config.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_enums.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_int.h create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_log.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_log.h create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_module.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_ucli.c create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/x86_64_accton_csp9250.mk create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/Makefile create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/Makefile create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/PKG.yml create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/src/lib/x86-64-accton-csp9250-r0.yml create mode 100755 packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/src/python/x86_64_accton_csp9250_r0/__init__.py diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/.gitignore b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/.gitignore new file mode 100755 index 00000000..f8bc5a4d --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/.gitignore @@ -0,0 +1,3 @@ +*x86*64*accton*as7312*54x*.mk +onlpdump.mk + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/Makefile b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/Makefile new file mode 100755 index 00000000..003238cf --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/Makefile @@ -0,0 +1 @@ +include $(ONL)/make/pkg.mk \ No newline at end of file diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/Makefile b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/Makefile new file mode 100755 index 00000000..003238cf --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/Makefile @@ -0,0 +1 @@ +include $(ONL)/make/pkg.mk \ No newline at end of file diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/PKG.yml b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/PKG.yml new file mode 100755 index 00000000..3f59762e --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/PKG.yml @@ -0,0 +1 @@ +!include $ONL_TEMPLATES/platform-modules.yml VENDOR=accton BASENAME=x86-64-accton-csp9250 ARCH=amd64 KERNELS="onl-kernel-3.16-lts-x86-64-all:amd64" diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/.gitignore b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/.gitignore new file mode 100755 index 00000000..a65b4177 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/.gitignore @@ -0,0 +1 @@ +lib diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/Makefile b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/Makefile new file mode 100755 index 00000000..1f3ab737 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/Makefile @@ -0,0 +1,6 @@ +KERNELS := onl-kernel-3.16-lts-x86-64-all:amd64 +KMODULES := $(wildcard *.c) +VENDOR := accton +BASENAME := x86-64-accton-csp9250 +ARCH := x86_64 +include $(ONL)/make/kmodule.mk diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-cpld.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-cpld.c new file mode 100755 index 00000000..a3021334 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-cpld.c @@ -0,0 +1,251 @@ +/* + * A hwmon driver for the accton_i2c_cpld + * + * Copyright (C) 2014 Accton Technology Corporation. + * Brandon Chuang + * + * Based on ad7414.c + * Copyright 2006 Stefan Roese , DENX Software Engineering + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include +#include +#include +#include + +static struct dmi_system_id csp9250_dmi_table[] = { + { + .ident = "Accton csp9250", + .matches = { + DMI_MATCH(DMI_BOARD_VENDOR, "Accton"), + DMI_MATCH(DMI_PRODUCT_NAME, "csp9250"), + }, + } +}; + +int platform_accton_csp9250(void) +{ + return dmi_check_system(csp9250_dmi_table); +} +EXPORT_SYMBOL(platform_accton_csp9250); + + +static LIST_HEAD(cpld_client_list); +static struct mutex list_lock; + +struct cpld_client_node { + struct i2c_client *client; + struct list_head list; +}; + +/* Addresses scanned for accton_i2c_cpld + */ +static const unsigned short normal_i2c[] = { 0x31, 0x35, 0x60, 0x62, 0x64, I2C_CLIENT_END }; + + +//#define DRIVER_CLASS_SWC_NAME "swc" +//static ssize_t accton_i2c_drv_version_get(struct device *dev, struct device_attribute *attr, char *buf); +//static SENSOR_DEVICE_ATTR(version, S_IRUGO, accton_i2c_drv_version_get, NULL, 0); +//static struct attribute *accton_attributes[] = { +// &sensor_dev_attr_version.dev_attr.attr, +// NULL, +//}; +//static struct attribute_group accton_attributes_group = { +// .attrs = accton_attributes, +//}; + +//struct accton_device { +// struct device *dev; + //struct kobject *kobject_version; +// int id; +// const char *name; + +//}; +//static struct class sysfs_class_swc = { +// .name = DRIVER_CLASS_SWC_NAME, + // .owner = THIS_MODULE, +//}; +//static struct accton_device accton_data; + +//#define DRIVER_VERSION "0.0.0.2" +/* +static ssize_t accton_i2c_drv_version_get(struct device *dev, struct device_attribute *attr, char *buf) +{ + int status = 0; + + status = snprintf(buf, PAGE_SIZE - 1, "\r%s\n", DRIVER_VERSION); + + return status; +} + +*/ + +static void accton_i2c_cpld_add_client(struct i2c_client *client) +{ + struct cpld_client_node *node = kzalloc(sizeof(struct cpld_client_node), GFP_KERNEL); + + if (!node) { + dev_dbg(&client->dev, "Can't allocate cpld_client_node (0x%x)\n", client->addr); + return; + } + + node->client = client; + + mutex_lock(&list_lock); + list_add(&node->list, &cpld_client_list); + mutex_unlock(&list_lock); +} + +static void accton_i2c_cpld_remove_client(struct i2c_client *client) +{ + struct list_head *list_node = NULL; + struct cpld_client_node *cpld_node = NULL; + int found = 0; + + mutex_lock(&list_lock); + + list_for_each(list_node, &cpld_client_list) + { + cpld_node = list_entry(list_node, struct cpld_client_node, list); + + if (cpld_node->client == client) { + found = 1; + break; + } + } + + if (found) { + list_del(list_node); + kfree(cpld_node); + } + + mutex_unlock(&list_lock); +} + +static int accton_i2c_cpld_probe(struct i2c_client *client, + const struct i2c_device_id *dev_id) +{ + int status; + + if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { + dev_dbg(&client->dev, "i2c_check_functionality failed (0x%x)\n", client->addr); + status = -EIO; + goto exit; + } + + dev_info(&client->dev, "chip found\n"); + accton_i2c_cpld_add_client(client); + + return 0; + +exit: + return status; +} + +static int accton_i2c_cpld_remove(struct i2c_client *client) +{ + accton_i2c_cpld_remove_client(client); + + return 0; +} + +static const struct i2c_device_id accton_i2c_cpld_id[] = { + { "accton_i2c_cpld", 0 }, + {} +}; +MODULE_DEVICE_TABLE(i2c, accton_i2c_cpld_id); + +static struct i2c_driver accton_i2c_cpld_driver = { + .class = I2C_CLASS_HWMON, + .driver = { + .name = "accton_i2c_cpld", + }, + .probe = accton_i2c_cpld_probe, + .remove = accton_i2c_cpld_remove, + .id_table = accton_i2c_cpld_id, + .address_list = normal_i2c, +}; + +int csp9250_i2c_cpld_read(unsigned short cpld_addr, u8 reg) +{ + struct list_head *list_node = NULL; + struct cpld_client_node *cpld_node = NULL; + int ret = -EPERM; + + mutex_lock(&list_lock); + + list_for_each(list_node, &cpld_client_list) + { + cpld_node = list_entry(list_node, struct cpld_client_node, list); + + if (cpld_node->client->addr == cpld_addr) { + ret = i2c_smbus_read_byte_data(cpld_node->client, reg); + break; + } + } + + mutex_unlock(&list_lock); + + return ret; +} +EXPORT_SYMBOL(csp9250_i2c_cpld_read); + +int csp9250_i2c_cpld_write(unsigned short cpld_addr, u8 reg, u8 value) +{ + struct list_head *list_node = NULL; + struct cpld_client_node *cpld_node = NULL; + int ret = -EIO; + + mutex_lock(&list_lock); + + list_for_each(list_node, &cpld_client_list) + { + cpld_node = list_entry(list_node, struct cpld_client_node, list); + + if (cpld_node->client->addr == cpld_addr) { + ret = i2c_smbus_write_byte_data(cpld_node->client, reg, value); + break; + } + } + + mutex_unlock(&list_lock); + + return ret; +} +EXPORT_SYMBOL(csp9250_i2c_cpld_write); + +static int __init accton_i2c_cpld_init(void) +{ + mutex_init(&list_lock); + return i2c_add_driver(&accton_i2c_cpld_driver); +} + +static void __exit accton_i2c_cpld_exit(void) +{ + i2c_del_driver(&accton_i2c_cpld_driver); +} + + +MODULE_AUTHOR("Brandon Chuang "); +MODULE_DESCRIPTION("accton_i2c_cpld driver"); +MODULE_LICENSE("GPL"); + +module_init(accton_i2c_cpld_init); +module_exit(accton_i2c_cpld_exit); diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-fan.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-fan.c new file mode 100755 index 00000000..9fee803a --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-fan.c @@ -0,0 +1,488 @@ +/* + * A hwmon driver for the Accton as7312 54x fan + * + * Copyright (C) 2014 Accton Technology Corporation. + * Brandon Chuang + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DRVNAME "csp9250_fan" + +static struct csp9250_fan_data *csp9250_fan_update_device(struct device *dev); +static ssize_t fan_show_value(struct device *dev, struct device_attribute *da, char *buf); +static ssize_t set_duty_cycle(struct device *dev, struct device_attribute *da, + const char *buf, size_t count); +extern int csp9250_i2c_cpld_read(unsigned short cpld_addr, u8 reg); +extern int csp9250_i2c_cpld_write(unsigned short cpld_addr, u8 reg, u8 value); + +/* fan related data, the index should match sysfs_fan_attributes + */ +static const u8 fan_reg[] = { + 0x0F, /* fan 1-6 present status */ + 0x10, /* fan 1-6 direction(0:F2B 1:B2F) */ + 0x11, /* fan PWM(for all fan) */ + 0x12, /* front fan 1 speed(rpm) */ + 0x13, /* front fan 2 speed(rpm) */ + 0x14, /* front fan 3 speed(rpm) */ + 0x15, /* front fan 4 speed(rpm) */ + 0x16, /* front fan 5 speed(rpm) */ + 0x17, /* front fan 6 speed(rpm) */ + 0x22, /* rear fan 1 speed(rpm) */ + 0x23, /* rear fan 2 speed(rpm) */ + 0x24, /* rear fan 3 speed(rpm) */ + 0x25, /* rear fan 4 speed(rpm) */ + 0x26, /* rear fan 5 speed(rpm) */ + 0x27, /* rear fan 6 speed(rpm) */ +}; + +/* Each client has this additional data */ +struct csp9250_fan_data { + struct device *hwmon_dev; + struct mutex update_lock; + char valid; /* != 0 if registers are valid */ + unsigned long last_updated; /* In jiffies */ + u8 reg_val[ARRAY_SIZE(fan_reg)]; /* Register value */ +}; + +enum fan_id { + FAN1_ID, + FAN2_ID, + FAN3_ID, + FAN4_ID, + FAN5_ID, + FAN6_ID +}; + +enum sysfs_fan_attributes { + FAN_PRESENT_REG, + FAN_DIRECTION_REG, + FAN_DUTY_CYCLE_PERCENTAGE, /* Only one CPLD register to control duty cycle for all fans */ + FAN1_FRONT_SPEED_RPM, + FAN2_FRONT_SPEED_RPM, + FAN3_FRONT_SPEED_RPM, + FAN4_FRONT_SPEED_RPM, + FAN5_FRONT_SPEED_RPM, + FAN6_FRONT_SPEED_RPM, + FAN1_REAR_SPEED_RPM, + FAN2_REAR_SPEED_RPM, + FAN3_REAR_SPEED_RPM, + FAN4_REAR_SPEED_RPM, + FAN5_REAR_SPEED_RPM, + FAN6_REAR_SPEED_RPM, + FAN1_DIRECTION, + FAN2_DIRECTION, + FAN3_DIRECTION, + FAN4_DIRECTION, + FAN5_DIRECTION, + FAN6_DIRECTION, + FAN1_PRESENT, + FAN2_PRESENT, + FAN3_PRESENT, + FAN4_PRESENT, + FAN5_PRESENT, + FAN6_PRESENT, + FAN1_FAULT, + FAN2_FAULT, + FAN3_FAULT, + FAN4_FAULT, + FAN5_FAULT, + FAN6_FAULT +}; + +/* Define attributes + */ +#define DECLARE_FAN_FAULT_SENSOR_DEV_ATTR(index) \ + static SENSOR_DEVICE_ATTR(fan##index##_fault, S_IRUGO, fan_show_value, NULL, FAN##index##_FAULT) +#define DECLARE_FAN_FAULT_ATTR(index) &sensor_dev_attr_fan##index##_fault.dev_attr.attr + +#define DECLARE_FAN_DIRECTION_SENSOR_DEV_ATTR(index) \ + static SENSOR_DEVICE_ATTR(fan##index##_direction, S_IRUGO, fan_show_value, NULL, FAN##index##_DIRECTION) +#define DECLARE_FAN_DIRECTION_ATTR(index) &sensor_dev_attr_fan##index##_direction.dev_attr.attr + +#define DECLARE_FAN_DUTY_CYCLE_SENSOR_DEV_ATTR(index) \ + static SENSOR_DEVICE_ATTR(fan##index##_duty_cycle_percentage, S_IWUSR | S_IRUGO, fan_show_value, set_duty_cycle, FAN##index##_DUTY_CYCLE_PERCENTAGE) +#define DECLARE_FAN_DUTY_CYCLE_ATTR(index) &sensor_dev_attr_fan##index##_duty_cycle_percentage.dev_attr.attr + +#define DECLARE_FAN_PRESENT_SENSOR_DEV_ATTR(index) \ + static SENSOR_DEVICE_ATTR(fan##index##_present, S_IRUGO, fan_show_value, NULL, FAN##index##_PRESENT) +#define DECLARE_FAN_PRESENT_ATTR(index) &sensor_dev_attr_fan##index##_present.dev_attr.attr + +#define DECLARE_FAN_SPEED_RPM_SENSOR_DEV_ATTR(index) \ + static SENSOR_DEVICE_ATTR(fan##index##_front_speed_rpm, S_IRUGO, fan_show_value, NULL, FAN##index##_FRONT_SPEED_RPM);\ + static SENSOR_DEVICE_ATTR(fan##index##_rear_speed_rpm, S_IRUGO, fan_show_value, NULL, FAN##index##_REAR_SPEED_RPM) +#define DECLARE_FAN_SPEED_RPM_ATTR(index) &sensor_dev_attr_fan##index##_front_speed_rpm.dev_attr.attr, \ + &sensor_dev_attr_fan##index##_rear_speed_rpm.dev_attr.attr + +/* 6 fan fault attributes in this platform */ +DECLARE_FAN_FAULT_SENSOR_DEV_ATTR(1); +DECLARE_FAN_FAULT_SENSOR_DEV_ATTR(2); +DECLARE_FAN_FAULT_SENSOR_DEV_ATTR(3); +DECLARE_FAN_FAULT_SENSOR_DEV_ATTR(4); +DECLARE_FAN_FAULT_SENSOR_DEV_ATTR(5); +DECLARE_FAN_FAULT_SENSOR_DEV_ATTR(6); +/* 6 fan speed(rpm) attributes in this platform */ +DECLARE_FAN_SPEED_RPM_SENSOR_DEV_ATTR(1); +DECLARE_FAN_SPEED_RPM_SENSOR_DEV_ATTR(2); +DECLARE_FAN_SPEED_RPM_SENSOR_DEV_ATTR(3); +DECLARE_FAN_SPEED_RPM_SENSOR_DEV_ATTR(4); +DECLARE_FAN_SPEED_RPM_SENSOR_DEV_ATTR(5); +DECLARE_FAN_SPEED_RPM_SENSOR_DEV_ATTR(6); +/* 6 fan present attributes in this platform */ +DECLARE_FAN_PRESENT_SENSOR_DEV_ATTR(1); +DECLARE_FAN_PRESENT_SENSOR_DEV_ATTR(2); +DECLARE_FAN_PRESENT_SENSOR_DEV_ATTR(3); +DECLARE_FAN_PRESENT_SENSOR_DEV_ATTR(4); +DECLARE_FAN_PRESENT_SENSOR_DEV_ATTR(5); +DECLARE_FAN_PRESENT_SENSOR_DEV_ATTR(6); +/* 6 fan direction attribute in this platform */ +DECLARE_FAN_DIRECTION_SENSOR_DEV_ATTR(1); +DECLARE_FAN_DIRECTION_SENSOR_DEV_ATTR(2); +DECLARE_FAN_DIRECTION_SENSOR_DEV_ATTR(3); +DECLARE_FAN_DIRECTION_SENSOR_DEV_ATTR(4); +DECLARE_FAN_DIRECTION_SENSOR_DEV_ATTR(5); +DECLARE_FAN_DIRECTION_SENSOR_DEV_ATTR(6); +/* 1 fan duty cycle attribute in this platform */ +DECLARE_FAN_DUTY_CYCLE_SENSOR_DEV_ATTR(); + +static struct attribute *csp9250_fan_attributes[] = { + /* fan related attributes */ + DECLARE_FAN_FAULT_ATTR(1), + DECLARE_FAN_FAULT_ATTR(2), + DECLARE_FAN_FAULT_ATTR(3), + DECLARE_FAN_FAULT_ATTR(4), + DECLARE_FAN_FAULT_ATTR(5), + DECLARE_FAN_FAULT_ATTR(6), + DECLARE_FAN_SPEED_RPM_ATTR(1), + DECLARE_FAN_SPEED_RPM_ATTR(2), + DECLARE_FAN_SPEED_RPM_ATTR(3), + DECLARE_FAN_SPEED_RPM_ATTR(4), + DECLARE_FAN_SPEED_RPM_ATTR(5), + DECLARE_FAN_SPEED_RPM_ATTR(6), + DECLARE_FAN_PRESENT_ATTR(1), + DECLARE_FAN_PRESENT_ATTR(2), + DECLARE_FAN_PRESENT_ATTR(3), + DECLARE_FAN_PRESENT_ATTR(4), + DECLARE_FAN_PRESENT_ATTR(5), + DECLARE_FAN_PRESENT_ATTR(6), + DECLARE_FAN_DIRECTION_ATTR(1), + DECLARE_FAN_DIRECTION_ATTR(2), + DECLARE_FAN_DIRECTION_ATTR(3), + DECLARE_FAN_DIRECTION_ATTR(4), + DECLARE_FAN_DIRECTION_ATTR(5), + DECLARE_FAN_DIRECTION_ATTR(6), + DECLARE_FAN_DUTY_CYCLE_ATTR(), + NULL +}; + +#define FAN_DUTY_CYCLE_REG_MASK 0xF +#define FAN_MAX_DUTY_CYCLE 100 +#define FAN_REG_VAL_TO_SPEED_RPM_STEP 100 + +static int csp9250_fan_read_value(struct i2c_client *client, u8 reg) +{ + return i2c_smbus_read_byte_data(client, reg); +} + +static int csp9250_fan_write_value(struct i2c_client *client, u8 reg, u8 value) +{ + return i2c_smbus_write_byte_data(client, reg, value); +} + +/* fan utility functions + */ +static u32 reg_val_to_duty_cycle(u8 reg_val) +{ + reg_val &= FAN_DUTY_CYCLE_REG_MASK; + return ((u32)(reg_val+1) * 625 + 75)/ 100; +} + +static u8 duty_cycle_to_reg_val(u8 duty_cycle) +{ + return ((u32)duty_cycle * 100 / 625) - 1; +} + +static u32 reg_val_to_speed_rpm(u8 reg_val) +{ + return (u32)reg_val * FAN_REG_VAL_TO_SPEED_RPM_STEP; +} + +static u8 reg_val_to_direction(u8 reg_val, enum fan_id id) +{ + u8 mask = (1 << id); + + reg_val &= mask; + + return reg_val ? 1 : 0; +} +static u8 reg_val_to_is_present(u8 reg_val, enum fan_id id) +{ + u8 mask = (1 << id); + + reg_val &= mask; + + return reg_val ? 0 : 1; +} + +static u8 is_fan_fault(struct csp9250_fan_data *data, enum fan_id id) +{ + u8 ret = 1; + int front_fan_index = FAN1_FRONT_SPEED_RPM + id; + int rear_fan_index = FAN1_REAR_SPEED_RPM + id; + + /* Check if the speed of front or rear fan is ZERO, + */ + if (reg_val_to_speed_rpm(data->reg_val[front_fan_index]) && + reg_val_to_speed_rpm(data->reg_val[rear_fan_index])) { + ret = 0; + } + + return ret; +} + +static ssize_t set_duty_cycle(struct device *dev, struct device_attribute *da, + const char *buf, size_t count) +{ + int error, value; + struct i2c_client *client = to_i2c_client(dev); + + error = kstrtoint(buf, 10, &value); + if (error) + return error; + + if (value < 0 || value > FAN_MAX_DUTY_CYCLE) + return -EINVAL; + + csp9250_fan_write_value(client, 0x33, 0); /* Disable fan speed watch dog */ + csp9250_fan_write_value(client, fan_reg[FAN_DUTY_CYCLE_PERCENTAGE], duty_cycle_to_reg_val(value)); + return count; +} + +static ssize_t fan_show_value(struct device *dev, struct device_attribute *da, + char *buf) +{ + struct sensor_device_attribute *attr = to_sensor_dev_attr(da); + struct csp9250_fan_data *data = csp9250_fan_update_device(dev); + ssize_t ret = 0; + + if (data->valid) { + switch (attr->index) { + case FAN_DUTY_CYCLE_PERCENTAGE: + { + u32 duty_cycle = reg_val_to_duty_cycle(data->reg_val[FAN_DUTY_CYCLE_PERCENTAGE]); + ret = sprintf(buf, "%u\n", duty_cycle); + break; + } + case FAN1_FRONT_SPEED_RPM: + case FAN2_FRONT_SPEED_RPM: + case FAN3_FRONT_SPEED_RPM: + case FAN4_FRONT_SPEED_RPM: + case FAN5_FRONT_SPEED_RPM: + case FAN6_FRONT_SPEED_RPM: + case FAN1_REAR_SPEED_RPM: + case FAN2_REAR_SPEED_RPM: + case FAN3_REAR_SPEED_RPM: + case FAN4_REAR_SPEED_RPM: + case FAN5_REAR_SPEED_RPM: + case FAN6_REAR_SPEED_RPM: + ret = sprintf(buf, "%u\n", reg_val_to_speed_rpm(data->reg_val[attr->index])); + break; + case FAN1_PRESENT: + case FAN2_PRESENT: + case FAN3_PRESENT: + case FAN4_PRESENT: + case FAN5_PRESENT: + case FAN6_PRESENT: + ret = sprintf(buf, "%d\n", + reg_val_to_is_present(data->reg_val[FAN_PRESENT_REG], + attr->index - FAN1_PRESENT)); + break; + case FAN1_FAULT: + case FAN2_FAULT: + case FAN3_FAULT: + case FAN4_FAULT: + case FAN5_FAULT: + case FAN6_FAULT: + ret = sprintf(buf, "%d\n", is_fan_fault(data, attr->index - FAN1_FAULT)); + break; + case FAN1_DIRECTION: + case FAN2_DIRECTION: + case FAN3_DIRECTION: + case FAN4_DIRECTION: + case FAN5_DIRECTION: + case FAN6_DIRECTION: + ret = sprintf(buf, "%d\n", + reg_val_to_direction(data->reg_val[FAN_DIRECTION_REG], + attr->index - FAN1_DIRECTION)); + break; + default: + break; + } + } + + return ret; +} + +static const struct attribute_group csp9250_fan_group = { + .attrs = csp9250_fan_attributes, +}; + +static struct csp9250_fan_data *csp9250_fan_update_device(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct csp9250_fan_data *data = i2c_get_clientdata(client); + + mutex_lock(&data->update_lock); + + if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || + !data->valid) { + int i; + + dev_dbg(&client->dev, "Starting csp9250_fan update\n"); + data->valid = 0; + + /* Update fan data + */ + for (i = 0; i < ARRAY_SIZE(data->reg_val); i++) { + int status = csp9250_fan_read_value(client, fan_reg[i]); + + if (status < 0) { + data->valid = 0; + mutex_unlock(&data->update_lock); + dev_dbg(&client->dev, "reg %d, err %d\n", fan_reg[i], status); + return data; + } + else { + data->reg_val[i] = status; + } + } + + data->last_updated = jiffies; + data->valid = 1; + } + + mutex_unlock(&data->update_lock); + + return data; +} + +static int csp9250_fan_probe(struct i2c_client *client, + const struct i2c_device_id *dev_id) +{ + struct csp9250_fan_data *data; + int status; + + if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { + status = -EIO; + goto exit; + } + + data = kzalloc(sizeof(struct csp9250_fan_data), GFP_KERNEL); + if (!data) { + status = -ENOMEM; + goto exit; + } + + i2c_set_clientdata(client, data); + data->valid = 0; + mutex_init(&data->update_lock); + + dev_info(&client->dev, "chip found\n"); + + /* Register sysfs hooks */ + status = sysfs_create_group(&client->dev.kobj, &csp9250_fan_group); + if (status) { + goto exit_free; + } + + data->hwmon_dev = hwmon_device_register(&client->dev); + if (IS_ERR(data->hwmon_dev)) { + status = PTR_ERR(data->hwmon_dev); + goto exit_remove; + } + + dev_info(&client->dev, "%s: fan '%s'\n", + dev_name(data->hwmon_dev), client->name); + + return 0; + +exit_remove: + sysfs_remove_group(&client->dev.kobj, &csp9250_fan_group); +exit_free: + kfree(data); +exit: + + return status; +} + +static int csp9250_fan_remove(struct i2c_client *client) +{ + struct csp9250_fan_data *data = i2c_get_clientdata(client); + hwmon_device_unregister(data->hwmon_dev); + sysfs_remove_group(&client->dev.kobj, &csp9250_fan_group); + + return 0; +} + +/* Addresses to scan */ +static const unsigned short normal_i2c[] = { 0x66, I2C_CLIENT_END }; + +static const struct i2c_device_id csp9250_fan_id[] = { + { "csp9250_fan", 0 }, + {} +}; +MODULE_DEVICE_TABLE(i2c, csp9250_fan_id); + +static struct i2c_driver csp9250_fan_driver = { + .class = I2C_CLASS_HWMON, + .driver = { + .name = DRVNAME, + }, + .probe = csp9250_fan_probe, + .remove = csp9250_fan_remove, + .id_table = csp9250_fan_id, + .address_list = normal_i2c, +}; + +static int __init csp9250_fan_init(void) +{ + + + return i2c_add_driver(&csp9250_fan_driver); +} + +static void __exit csp9250_fan_exit(void) +{ + i2c_del_driver(&csp9250_fan_driver); +} + +module_init(csp9250_fan_init); +module_exit(csp9250_fan_exit); + +MODULE_AUTHOR("Brandon Chuang "); +MODULE_DESCRIPTION("csp9250_fan driver"); +MODULE_LICENSE("GPL"); + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-leds.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-leds.c new file mode 100755 index 00000000..f3a2f878 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-leds.c @@ -0,0 +1,438 @@ +/* + * A LED driver for the accton_csp9250_led + * + * Copyright (C) 2014 Accton Technology Corporation. + * Brandon Chuang + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/*#define DEBUG*/ + +#include +#include +#include +#include +#include +#include +#include +#include + +extern int csp9250_i2c_cpld_read (unsigned short cpld_addr, u8 reg); +extern int csp9250_i2c_cpld_write(unsigned short cpld_addr, u8 reg, u8 value); + +extern void led_classdev_unregister(struct led_classdev *led_cdev); +extern int led_classdev_register(struct device *parent, struct led_classdev *led_cdev); +extern void led_classdev_resume(struct led_classdev *led_cdev); +extern void led_classdev_suspend(struct led_classdev *led_cdev); + +#define DRVNAME "accton_csp9250_led" + +struct accton_csp9250_led_data { + struct platform_device *pdev; + struct mutex update_lock; + char valid; /* != 0 if registers are valid */ + unsigned long last_updated; /* In jiffies */ + u8 reg_val[1]; /* only 1 register*/ +}; + +static struct accton_csp9250_led_data *ledctl = NULL; + +/* LED related data + */ + +#define LED_CNTRLER_I2C_ADDRESS (0x60) + +#define LED_TYPE_DIAG_REG_MASK (0x3) +#define LED_MODE_DIAG_GREEN_VALUE (0x02) +#define LED_MODE_DIAG_RED_VALUE (0x01) +#define LED_MODE_DIAG_AMBER_VALUE (0x00) /*It's yellow actually. Green+Red=Yellow*/ +#define LED_MODE_DIAG_OFF_VALUE (0x03) + + +#define LED_TYPE_LOC_REG_MASK (0x80) +#define LED_MODE_LOC_ON_VALUE (0) +#define LED_MODE_LOC_OFF_VALUE (0x80) + +enum led_type { + LED_TYPE_DIAG, + LED_TYPE_LOC, + LED_TYPE_FAN, + LED_TYPE_PSU1, + LED_TYPE_PSU2 +}; + +struct led_reg { + u32 types; + u8 reg_addr; +}; + +static const struct led_reg led_reg_map[] = { + {(1<update_lock); + + if (time_after(jiffies, ledctl->last_updated + HZ + HZ / 2) + || !ledctl->valid) { + int i; + + dev_dbg(&ledctl->pdev->dev, "Starting accton_csp9250_led update\n"); + + /* Update LED data + */ + for (i = 0; i < ARRAY_SIZE(ledctl->reg_val); i++) { + int status = accton_csp9250_led_read_value(led_reg_map[i].reg_addr); + + if (status < 0) { + ledctl->valid = 0; + dev_dbg(&ledctl->pdev->dev, "reg %d, err %d\n", led_reg_map[i].reg_addr, status); + goto exit; + } + else + { + ledctl->reg_val[i] = status; + } + } + + ledctl->last_updated = jiffies; + ledctl->valid = 1; + } + +exit: + mutex_unlock(&ledctl->update_lock); +} + +static void accton_csp9250_led_set(struct led_classdev *led_cdev, + enum led_brightness led_light_mode, + enum led_type type) +{ + int reg_val; + u8 reg ; + mutex_lock(&ledctl->update_lock); + + if( !accton_getLedReg(type, ®)) + { + dev_dbg(&ledctl->pdev->dev, "Not match item for %d.\n", type); + } + + reg_val = accton_csp9250_led_read_value(reg); + + if (reg_val < 0) { + dev_dbg(&ledctl->pdev->dev, "reg %d, err %d\n", reg, reg_val); + goto exit; + } + reg_val = led_light_mode_to_reg_val(type, led_light_mode, reg_val); + accton_csp9250_led_write_value(reg, reg_val); + + /* to prevent the slow-update issue */ + ledctl->valid = 0; + +exit: + mutex_unlock(&ledctl->update_lock); +} + + +static void accton_csp9250_led_diag_set(struct led_classdev *led_cdev, + enum led_brightness led_light_mode) +{ + accton_csp9250_led_set(led_cdev, led_light_mode, LED_TYPE_DIAG); +} + +static enum led_brightness accton_csp9250_led_diag_get(struct led_classdev *cdev) +{ + accton_csp9250_led_update(); + return led_reg_val_to_light_mode(LED_TYPE_DIAG, ledctl->reg_val[0]); +} + +static void accton_csp9250_led_loc_set(struct led_classdev *led_cdev, + enum led_brightness led_light_mode) +{ + accton_csp9250_led_set(led_cdev, led_light_mode, LED_TYPE_LOC); +} + +static enum led_brightness accton_csp9250_led_loc_get(struct led_classdev *cdev) +{ + accton_csp9250_led_update(); + return led_reg_val_to_light_mode(LED_TYPE_LOC, ledctl->reg_val[0]); +} + +static void accton_csp9250_led_auto_set(struct led_classdev *led_cdev, + enum led_brightness led_light_mode) +{ +} + +static enum led_brightness accton_csp9250_led_auto_get(struct led_classdev *cdev) +{ + return LED_MODE_AUTO; +} + +static struct led_classdev accton_csp9250_leds[] = { + [LED_TYPE_DIAG] = { + .name = "accton_csp9250_led::diag", + .default_trigger = "unused", + .brightness_set = accton_csp9250_led_diag_set, + .brightness_get = accton_csp9250_led_diag_get, + .flags = LED_CORE_SUSPENDRESUME, + .max_brightness = LED_MODE_RED, + }, + [LED_TYPE_LOC] = { + .name = "accton_csp9250_led::loc", + .default_trigger = "unused", + .brightness_set = accton_csp9250_led_loc_set, + .brightness_get = accton_csp9250_led_loc_get, + .flags = LED_CORE_SUSPENDRESUME, + .max_brightness = LED_MODE_BLUE, + }, + [LED_TYPE_FAN] = { + .name = "accton_csp9250_led::fan", + .default_trigger = "unused", + .brightness_set = accton_csp9250_led_auto_set, + .brightness_get = accton_csp9250_led_auto_get, + .flags = LED_CORE_SUSPENDRESUME, + .max_brightness = LED_MODE_AUTO, + }, + [LED_TYPE_PSU1] = { + .name = "accton_csp9250_led::psu1", + .default_trigger = "unused", + .brightness_set = accton_csp9250_led_auto_set, + .brightness_get = accton_csp9250_led_auto_get, + .flags = LED_CORE_SUSPENDRESUME, + .max_brightness = LED_MODE_AUTO, + }, + [LED_TYPE_PSU2] = { + .name = "accton_csp9250_led::psu2", + .default_trigger = "unused", + .brightness_set = accton_csp9250_led_auto_set, + .brightness_get = accton_csp9250_led_auto_get, + .flags = LED_CORE_SUSPENDRESUME, + .max_brightness = LED_MODE_AUTO, + }, +}; + +static int accton_csp9250_led_suspend(struct platform_device *dev, + pm_message_t state) +{ + int i = 0; + + for (i = 0; i < ARRAY_SIZE(accton_csp9250_leds); i++) { + led_classdev_suspend(&accton_csp9250_leds[i]); + } + + return 0; +} + +static int accton_csp9250_led_resume(struct platform_device *dev) +{ + int i = 0; + + for (i = 0; i < ARRAY_SIZE(accton_csp9250_leds); i++) { + led_classdev_resume(&accton_csp9250_leds[i]); + } + + return 0; +} + +static int accton_csp9250_led_probe(struct platform_device *pdev) +{ + int ret, i; + + for (i = 0; i < ARRAY_SIZE(accton_csp9250_leds); i++) { + ret = led_classdev_register(&pdev->dev, &accton_csp9250_leds[i]); + + if (ret < 0) + break; + } + + /* Check if all LEDs were successfully registered */ + if (i != ARRAY_SIZE(accton_csp9250_leds)) { + int j; + + /* only unregister the LEDs that were successfully registered */ + for (j = 0; j < i; j++) { + led_classdev_unregister(&accton_csp9250_leds[i]); + } + } + + return ret; +} + +static int accton_csp9250_led_remove(struct platform_device *pdev) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(accton_csp9250_leds); i++) { + led_classdev_unregister(&accton_csp9250_leds[i]); + } + + return 0; +} + +static struct platform_driver accton_csp9250_led_driver = { + .probe = accton_csp9250_led_probe, + .remove = accton_csp9250_led_remove, + .suspend = accton_csp9250_led_suspend, + .resume = accton_csp9250_led_resume, + .driver = { + .name = DRVNAME, + .owner = THIS_MODULE, + }, +}; + +static int __init accton_csp9250_led_init(void) +{ + int ret; + + ret = platform_driver_register(&accton_csp9250_led_driver); + if (ret < 0) { + goto exit; + } + + ledctl = kzalloc(sizeof(struct accton_csp9250_led_data), GFP_KERNEL); + if (!ledctl) { + ret = -ENOMEM; + platform_driver_unregister(&accton_csp9250_led_driver); + goto exit; + } + + mutex_init(&ledctl->update_lock); + + ledctl->pdev = platform_device_register_simple(DRVNAME, -1, NULL, 0); + if (IS_ERR(ledctl->pdev)) { + ret = PTR_ERR(ledctl->pdev); + platform_driver_unregister(&accton_csp9250_led_driver); + kfree(ledctl); + goto exit; + } + +exit: + return ret; +} + +static void __exit accton_csp9250_led_exit(void) +{ + platform_device_unregister(ledctl->pdev); + platform_driver_unregister(&accton_csp9250_led_driver); + kfree(ledctl); +} + +module_init(accton_csp9250_led_init); +module_exit(accton_csp9250_led_exit); + +MODULE_AUTHOR("Brandon Chuang "); +MODULE_DESCRIPTION("accton_csp9250_led driver"); +MODULE_LICENSE("GPL"); diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-psu.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-psu.c new file mode 100755 index 00000000..659b151a --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-psu.c @@ -0,0 +1,293 @@ +/* + * An hwmon driver for accton csp9250 Power Module + * + * Copyright (C) 2014 Accton Technology Corporation. + * Brandon Chuang + * + * Based on ad7414.c + * Copyright 2006 Stefan Roese , DENX Software Engineering + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static ssize_t show_status(struct device *dev, struct device_attribute *da, char *buf); +static ssize_t show_model_name(struct device *dev, struct device_attribute *da, char *buf); +static int csp9250_psu_read_block(struct i2c_client *client, u8 command, u8 *data,int data_len); +extern int csp9250_i2c_cpld_read(unsigned short cpld_addr, u8 reg); + +/* Addresses scanned + */ +static const unsigned short normal_i2c[] = { 0x50, 0x53, I2C_CLIENT_END }; + +/* Each client has this additional data + */ +struct csp9250_psu_data { + struct device *hwmon_dev; + struct mutex update_lock; + char valid; /* !=0 if registers are valid */ + unsigned long last_updated; /* In jiffies */ + u8 index; /* PSU index */ + u8 status; /* Status(present/power_good) register read from CPLD */ + char model_name[9]; /* Model name, read from eeprom */ +}; + +static struct csp9250_psu_data *csp9250_psu_update_device(struct device *dev); + +enum csp9250_psu_sysfs_attributes { + PSU_PRESENT, + PSU_MODEL_NAME, + PSU_POWER_GOOD +}; + +/* sysfs attributes for hwmon + */ +static SENSOR_DEVICE_ATTR(psu_present, S_IRUGO, show_status, NULL, PSU_PRESENT); +static SENSOR_DEVICE_ATTR(psu_model_name, S_IRUGO, show_model_name,NULL, PSU_MODEL_NAME); +static SENSOR_DEVICE_ATTR(psu_power_good, S_IRUGO, show_status, NULL, PSU_POWER_GOOD); + +static struct attribute *csp9250_psu_attributes[] = { + &sensor_dev_attr_psu_present.dev_attr.attr, + &sensor_dev_attr_psu_model_name.dev_attr.attr, + &sensor_dev_attr_psu_power_good.dev_attr.attr, + NULL +}; + +static ssize_t show_status(struct device *dev, struct device_attribute *da, + char *buf) +{ + struct sensor_device_attribute *attr = to_sensor_dev_attr(da); + struct csp9250_psu_data *data = csp9250_psu_update_device(dev); + u8 status = 0; + + if (attr->index == PSU_PRESENT) { + status = !(data->status >> (1-data->index) & 0x1); + } + else { /* PSU_POWER_GOOD */ + status = (data->status >> (3-data->index) & 0x1); + } + + return sprintf(buf, "%d\n", status); +} + +static ssize_t show_model_name(struct device *dev, struct device_attribute *da, + char *buf) +{ + struct csp9250_psu_data *data = csp9250_psu_update_device(dev); + + return sprintf(buf, "%s\n", data->model_name); +} + +static const struct attribute_group csp9250_psu_group = { + .attrs = csp9250_psu_attributes, +}; + +static int csp9250_psu_probe(struct i2c_client *client, + const struct i2c_device_id *dev_id) +{ + struct csp9250_psu_data *data; + int status; + + if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) { + status = -EIO; + goto exit; + } + + data = kzalloc(sizeof(struct csp9250_psu_data), GFP_KERNEL); + if (!data) { + status = -ENOMEM; + goto exit; + } + + i2c_set_clientdata(client, data); + data->valid = 0; + data->index = dev_id->driver_data; + mutex_init(&data->update_lock); + + dev_info(&client->dev, "chip found\n"); + + /* Register sysfs hooks */ + status = sysfs_create_group(&client->dev.kobj, &csp9250_psu_group); + if (status) { + goto exit_free; + } + + data->hwmon_dev = hwmon_device_register(&client->dev); + if (IS_ERR(data->hwmon_dev)) { + status = PTR_ERR(data->hwmon_dev); + goto exit_remove; + } + + dev_info(&client->dev, "%s: psu '%s'\n", + dev_name(data->hwmon_dev), client->name); + + return 0; + +exit_remove: + sysfs_remove_group(&client->dev.kobj, &csp9250_psu_group); +exit_free: + kfree(data); +exit: + + return status; +} + +static int csp9250_psu_remove(struct i2c_client *client) +{ + struct csp9250_psu_data *data = i2c_get_clientdata(client); + + hwmon_device_unregister(data->hwmon_dev); + sysfs_remove_group(&client->dev.kobj, &csp9250_psu_group); + kfree(data); + + return 0; +} + +enum psu_index +{ + csp9250_psu1, + csp9250_psu2 +}; + +static const struct i2c_device_id csp9250_psu_id[] = { + { "csp9250_psu1", csp9250_psu1 }, + { "csp9250_psu2", csp9250_psu2 }, + {} +}; +MODULE_DEVICE_TABLE(i2c, csp9250_psu_id); + +static struct i2c_driver csp9250_psu_driver = { + .class = I2C_CLASS_HWMON, + .driver = { + .name = "csp9250_psu", + }, + .probe = csp9250_psu_probe, + .remove = csp9250_psu_remove, + .id_table = csp9250_psu_id, + .address_list = normal_i2c, +}; + +static int csp9250_psu_read_block(struct i2c_client *client, u8 command, u8 *data, + int data_len) +{ + int result = 0; + int retry_count = 5; + + while (retry_count) { + retry_count--; + + result = i2c_smbus_read_i2c_block_data(client, command, data_len, data); + + if (unlikely(result < 0)) { + msleep(10); + continue; + } + + if (unlikely(result != data_len)) { + result = -EIO; + msleep(10); + continue; + } + + result = 0; + break; + } + + return result; +} + +static struct csp9250_psu_data *csp9250_psu_update_device(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct csp9250_psu_data *data = i2c_get_clientdata(client); + + mutex_lock(&data->update_lock); + + if (time_after(jiffies, data->last_updated + HZ + HZ / 2) + || !data->valid) { + int status; + int power_good = 0; + + dev_dbg(&client->dev, "Starting csp9250 update\n"); + + /* Read psu status */ + status = csp9250_i2c_cpld_read(0x60, 0x2); + + if (status < 0) { + dev_dbg(&client->dev, "cpld reg 0x60 err %d\n", status); + } + else { + data->status = status; + } + + /* Read model name */ + memset(data->model_name, 0, sizeof(data->model_name)); + power_good = (data->status >> (3-data->index) & 0x1); + + if (power_good) { + status = csp9250_psu_read_block(client, 0x20, data->model_name, + ARRAY_SIZE(data->model_name)-1); + + if (status < 0) { + data->model_name[0] = '\0'; + dev_dbg(&client->dev, "unable to read model name from (0x%x)\n", client->addr); + } + else { + data->model_name[ARRAY_SIZE(data->model_name)-1] = '\0'; + } + } + + data->last_updated = jiffies; + data->valid = 1; + } + + mutex_unlock(&data->update_lock); + + return data; +} + +static int __init csp9250_psu_init(void) +{ + extern int platform_accton_csp9250(void); + if (!platform_accton_csp9250()) { + return -ENODEV; + } + + return i2c_add_driver(&csp9250_psu_driver); +} + +static void __exit csp9250_psu_exit(void) +{ + i2c_del_driver(&csp9250_psu_driver); +} + +module_init(csp9250_psu_init); +module_exit(csp9250_psu_exit); + +MODULE_AUTHOR("Brandon Chuang "); +MODULE_DESCRIPTION("csp9250_psu driver"); +MODULE_LICENSE("GPL"); + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-sfp.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-sfp.c new file mode 100755 index 00000000..d13bf7c9 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/modules/builds/x86-64-accton-csp9250-sfp.c @@ -0,0 +1,1354 @@ +/* + * SFP driver for accton csp9250 sfp + * + * Copyright (C) Brandon Chuang + * + * Based on ad7414.c + * Copyright 2006 Stefan Roese , DENX Software Engineering + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DRIVER_NAME "csp9250_sfp" /* Platform dependent */ + +#define DEBUG_MODE 0 + +#if (DEBUG_MODE == 1) +#define DEBUG_PRINT(fmt, args...) \ + printk (KERN_INFO "%s:%s[%d]: " fmt "\r\n", __FILE__, __FUNCTION__, __LINE__, ##args) +#else +#define DEBUG_PRINT(fmt, args...) +#endif + +#define NUM_OF_SFP_PORT 54 +#define EEPROM_NAME "sfp_eeprom" +#define EEPROM_SIZE 256 /* 256 byte eeprom */ +#define BIT_INDEX(i) (1ULL << (i)) +#define USE_I2C_BLOCK_READ 1 /* Platform dependent */ +#define I2C_RW_RETRY_COUNT 3 +#define I2C_RW_RETRY_INTERVAL 100 /* ms */ + +#define SFP_EEPROM_A0_I2C_ADDR (0xA0 >> 1) +#define SFP_EEPROM_A2_I2C_ADDR (0xA2 >> 1) + +#define SFF8024_PHYSICAL_DEVICE_ID_ADDR 0x0 +#define SFF8024_DEVICE_ID_SFP 0x3 +#define SFF8024_DEVICE_ID_QSFP 0xC +#define SFF8024_DEVICE_ID_QSFP_PLUS 0xD +#define SFF8024_DEVICE_ID_QSFP28 0x11 + +#define SFF8472_DIAG_MON_TYPE_ADDR 92 +#define SFF8472_DIAG_MON_TYPE_DDM_MASK 0x40 +#define SFF8472_10G_ETH_COMPLIANCE_ADDR 0x3 +#define SFF8472_10G_BASE_MASK 0xF0 + +#define SFF8436_RX_LOS_ADDR 3 +#define SFF8436_TX_FAULT_ADDR 4 +#define SFF8436_TX_DISABLE_ADDR 86 + +/* Platform dependent +++ */ +#define I2C_ADDR_CPLD1 0x60 +#define I2C_ADDR_CPLD2 0x62 +#define I2C_ADDR_CPLD3 0x64 +/* Platform dependent --- */ +static ssize_t show_port_number(struct device *dev, struct device_attribute *da, char *buf); +static ssize_t show_port_type(struct device *dev, struct device_attribute *da, char *buf); +static ssize_t show_present(struct device *dev, struct device_attribute *da, char *buf); +static ssize_t sfp_show_tx_rx_status(struct device *dev, struct device_attribute *da, char *buf); +static ssize_t qsfp_show_tx_rx_status(struct device *dev, struct device_attribute *da, char *buf); +static ssize_t sfp_set_tx_disable(struct device *dev, struct device_attribute *da, const char *buf, size_t count); +static ssize_t qsfp_set_tx_disable(struct device *dev, struct device_attribute *da, const char *buf, size_t count);; +static ssize_t sfp_show_ddm_implemented(struct device *dev, struct device_attribute *da, char *buf); +static ssize_t sfp_eeprom_read(struct i2c_client *, u8, u8 *,int); +static ssize_t sfp_eeprom_write(struct i2c_client *, u8 , const char *,int); +extern int csp9250_i2c_cpld_read(unsigned short cpld_addr, u8 reg); +extern int csp9250_i2c_cpld_write(unsigned short cpld_addr, u8 reg, u8 value); +enum sfp_sysfs_attributes { + PRESENT, + PRESENT_ALL, + PORT_NUMBER, + PORT_TYPE, + DDM_IMPLEMENTED, + TX_FAULT, + TX_FAULT1, + TX_FAULT2, + TX_FAULT3, + TX_FAULT4, + TX_DISABLE, + TX_DISABLE1, + TX_DISABLE2, + TX_DISABLE3, + TX_DISABLE4, + RX_LOS, + RX_LOS1, + RX_LOS2, + RX_LOS3, + RX_LOS4, + RX_LOS_ALL +}; + +/* SFP/QSFP common attributes for sysfs */ +static SENSOR_DEVICE_ATTR(sfp_port_number, S_IRUGO, show_port_number, NULL, PORT_NUMBER); +static SENSOR_DEVICE_ATTR(sfp_port_type, S_IRUGO, show_port_type, NULL, PORT_TYPE); +static SENSOR_DEVICE_ATTR(sfp_is_present, S_IRUGO, show_present, NULL, PRESENT); +static SENSOR_DEVICE_ATTR(sfp_is_present_all, S_IRUGO, show_present, NULL, PRESENT_ALL); +static SENSOR_DEVICE_ATTR(sfp_rx_los, S_IRUGO, sfp_show_tx_rx_status, NULL, RX_LOS); +static SENSOR_DEVICE_ATTR(sfp_tx_disable, S_IWUSR | S_IRUGO, sfp_show_tx_rx_status, sfp_set_tx_disable, TX_DISABLE); +static SENSOR_DEVICE_ATTR(sfp_tx_fault, S_IRUGO, sfp_show_tx_rx_status, NULL, TX_FAULT); + +/* QSFP attributes for sysfs */ +static SENSOR_DEVICE_ATTR(sfp_rx_los1, S_IRUGO, qsfp_show_tx_rx_status, NULL, RX_LOS1); +static SENSOR_DEVICE_ATTR(sfp_rx_los2, S_IRUGO, qsfp_show_tx_rx_status, NULL, RX_LOS2); +static SENSOR_DEVICE_ATTR(sfp_rx_los3, S_IRUGO, qsfp_show_tx_rx_status, NULL, RX_LOS3); +static SENSOR_DEVICE_ATTR(sfp_rx_los4, S_IRUGO, qsfp_show_tx_rx_status, NULL, RX_LOS4); +static SENSOR_DEVICE_ATTR(sfp_tx_disable1, S_IWUSR | S_IRUGO, qsfp_show_tx_rx_status, qsfp_set_tx_disable, TX_DISABLE1); +static SENSOR_DEVICE_ATTR(sfp_tx_disable2, S_IWUSR | S_IRUGO, qsfp_show_tx_rx_status, qsfp_set_tx_disable, TX_DISABLE2); +static SENSOR_DEVICE_ATTR(sfp_tx_disable3, S_IWUSR | S_IRUGO, qsfp_show_tx_rx_status, qsfp_set_tx_disable, TX_DISABLE3); +static SENSOR_DEVICE_ATTR(sfp_tx_disable4, S_IWUSR | S_IRUGO, qsfp_show_tx_rx_status, qsfp_set_tx_disable, TX_DISABLE4); +static SENSOR_DEVICE_ATTR(sfp_tx_fault1, S_IRUGO, qsfp_show_tx_rx_status, NULL, TX_FAULT1); +static SENSOR_DEVICE_ATTR(sfp_tx_fault2, S_IRUGO, qsfp_show_tx_rx_status, NULL, TX_FAULT2); +static SENSOR_DEVICE_ATTR(sfp_tx_fault3, S_IRUGO, qsfp_show_tx_rx_status, NULL, TX_FAULT3); +static SENSOR_DEVICE_ATTR(sfp_tx_fault4, S_IRUGO, qsfp_show_tx_rx_status, NULL, TX_FAULT4); +static struct attribute *qsfp_attributes[] = { + &sensor_dev_attr_sfp_port_number.dev_attr.attr, + &sensor_dev_attr_sfp_port_type.dev_attr.attr, + &sensor_dev_attr_sfp_is_present.dev_attr.attr, + &sensor_dev_attr_sfp_is_present_all.dev_attr.attr, + &sensor_dev_attr_sfp_rx_los.dev_attr.attr, + &sensor_dev_attr_sfp_rx_los1.dev_attr.attr, + &sensor_dev_attr_sfp_rx_los2.dev_attr.attr, + &sensor_dev_attr_sfp_rx_los3.dev_attr.attr, + &sensor_dev_attr_sfp_rx_los4.dev_attr.attr, + &sensor_dev_attr_sfp_tx_disable.dev_attr.attr, + &sensor_dev_attr_sfp_tx_disable1.dev_attr.attr, + &sensor_dev_attr_sfp_tx_disable2.dev_attr.attr, + &sensor_dev_attr_sfp_tx_disable3.dev_attr.attr, + &sensor_dev_attr_sfp_tx_disable4.dev_attr.attr, + &sensor_dev_attr_sfp_tx_fault.dev_attr.attr, + &sensor_dev_attr_sfp_tx_fault1.dev_attr.attr, + &sensor_dev_attr_sfp_tx_fault2.dev_attr.attr, + &sensor_dev_attr_sfp_tx_fault3.dev_attr.attr, + &sensor_dev_attr_sfp_tx_fault4.dev_attr.attr, + NULL +}; + +/* SFP msa attributes for sysfs */ +static SENSOR_DEVICE_ATTR(sfp_ddm_implemented, S_IRUGO, sfp_show_ddm_implemented, NULL, DDM_IMPLEMENTED); +static SENSOR_DEVICE_ATTR(sfp_rx_los_all, S_IRUGO, sfp_show_tx_rx_status, NULL, RX_LOS_ALL); +static struct attribute *sfp_msa_attributes[] = { + &sensor_dev_attr_sfp_port_number.dev_attr.attr, + &sensor_dev_attr_sfp_port_type.dev_attr.attr, + &sensor_dev_attr_sfp_is_present.dev_attr.attr, + &sensor_dev_attr_sfp_is_present_all.dev_attr.attr, + &sensor_dev_attr_sfp_ddm_implemented.dev_attr.attr, + &sensor_dev_attr_sfp_tx_fault.dev_attr.attr, + &sensor_dev_attr_sfp_rx_los.dev_attr.attr, + &sensor_dev_attr_sfp_rx_los_all.dev_attr.attr, + &sensor_dev_attr_sfp_tx_disable.dev_attr.attr, + NULL +}; + +/* SFP ddm attributes for sysfs */ +static struct attribute *sfp_ddm_attributes[] = { + NULL +}; + +/* Platform dependent +++ */ +#define CPLD_PORT_TO_FRONT_PORT(port) (port+1) + +enum port_numbers { + csp9250_sfp1, csp9250_sfp2, csp9250_sfp3, csp9250_sfp4, csp9250_sfp5, csp9250_sfp6, csp9250_sfp7, csp9250_sfp8, + csp9250_sfp9, csp9250_sfp10, csp9250_sfp11, csp9250_sfp12, csp9250_sfp13, csp9250_sfp14, csp9250_sfp15, csp9250_sfp16, + csp9250_sfp17, csp9250_sfp18, csp9250_sfp19, csp9250_sfp20, csp9250_sfp21, csp9250_sfp22, csp9250_sfp23, csp9250_sfp24, + csp9250_sfp25, csp9250_sfp26, csp9250_sfp27, csp9250_sfp28, csp9250_sfp29, csp9250_sfp30, csp9250_sfp31, csp9250_sfp32, + csp9250_sfp33, csp9250_sfp34, csp9250_sfp35, csp9250_sfp36, csp9250_sfp37, csp9250_sfp38, csp9250_sfp39, csp9250_sfp40, + csp9250_sfp41, csp9250_sfp42, csp9250_sfp43, csp9250_sfp44, csp9250_sfp45, csp9250_sfp46, csp9250_sfp47, csp9250_sfp48, + csp9250_sfp49, csp9250_sfp50, csp9250_sfp51, csp9250_sfp52, csp9250_sfp53, csp9250_sfp54 +}; +#define DEV_NAME_ID(x) {#x, x} +static const struct i2c_device_id csp9250_sfp_id[] = { +#if 1 + DEV_NAME_ID(csp9250_sfp1), DEV_NAME_ID(csp9250_sfp2), + DEV_NAME_ID(csp9250_sfp3), DEV_NAME_ID(csp9250_sfp4), + DEV_NAME_ID(csp9250_sfp5), DEV_NAME_ID(csp9250_sfp6), + DEV_NAME_ID(csp9250_sfp7), DEV_NAME_ID(csp9250_sfp8), + DEV_NAME_ID(csp9250_sfp9), DEV_NAME_ID(csp9250_sfp10), + DEV_NAME_ID(csp9250_sfp11), DEV_NAME_ID(csp9250_sfp12), + DEV_NAME_ID(csp9250_sfp13), DEV_NAME_ID(csp9250_sfp14), + DEV_NAME_ID(csp9250_sfp15), DEV_NAME_ID(csp9250_sfp16), + DEV_NAME_ID(csp9250_sfp17), DEV_NAME_ID(csp9250_sfp18), + DEV_NAME_ID(csp9250_sfp19), DEV_NAME_ID(csp9250_sfp20), + DEV_NAME_ID(csp9250_sfp21), DEV_NAME_ID(csp9250_sfp22), + DEV_NAME_ID(csp9250_sfp23), DEV_NAME_ID(csp9250_sfp24), + DEV_NAME_ID(csp9250_sfp25), DEV_NAME_ID(csp9250_sfp26), + DEV_NAME_ID(csp9250_sfp27), DEV_NAME_ID(csp9250_sfp28), + DEV_NAME_ID(csp9250_sfp29), DEV_NAME_ID(csp9250_sfp30), + DEV_NAME_ID(csp9250_sfp31), DEV_NAME_ID(csp9250_sfp32), + DEV_NAME_ID(csp9250_sfp33), DEV_NAME_ID(csp9250_sfp34), + DEV_NAME_ID(csp9250_sfp35), DEV_NAME_ID(csp9250_sfp36), + DEV_NAME_ID(csp9250_sfp37), DEV_NAME_ID(csp9250_sfp38), + DEV_NAME_ID(csp9250_sfp39), DEV_NAME_ID(csp9250_sfp40), + DEV_NAME_ID(csp9250_sfp41), DEV_NAME_ID(csp9250_sfp42), + DEV_NAME_ID(csp9250_sfp43), DEV_NAME_ID(csp9250_sfp44), + DEV_NAME_ID(csp9250_sfp45), DEV_NAME_ID(csp9250_sfp46), + DEV_NAME_ID(csp9250_sfp47), DEV_NAME_ID(csp9250_sfp48), + DEV_NAME_ID(csp9250_sfp49), DEV_NAME_ID(csp9250_sfp50), + DEV_NAME_ID(csp9250_sfp51), DEV_NAME_ID(csp9250_sfp52), + DEV_NAME_ID(csp9250_sfp53), DEV_NAME_ID(csp9250_sfp54), +#else + { "csp9250_sfp1", csp9250_sfp1 }, { "csp9250_sfp2", csp9250_sfp2 }, { "csp9250_sfp3", csp9250_sfp3 }, { "csp9250_sfp4", csp9250_sfp4 }, + { "csp9250_sfp5", csp9250_sfp5 }, { "csp9250_sfp6", csp9250_sfp6 }, { "csp9250_sfp7", csp9250_sfp7 }, { "csp9250_sfp8", csp9250_sfp8 }, + { "csp9250_sfp9", csp9250_sfp9 }, { "csp9250_sfp10", csp9250_sfp10 }, { "csp9250_sfp11", csp9250_sfp11 }, { "csp9250_sfp12", csp9250_sfp12 }, + { "csp9250_sfp13", csp9250_sfp13 }, { "csp9250_sfp14", csp9250_sfp14 }, { "csp9250_sfp15", csp9250_sfp15 }, { "csp9250_sfp16", csp9250_sfp16 }, + { "csp9250_sfp17", csp9250_sfp17 }, { "csp9250_sfp18", csp9250_sfp18 }, { "csp9250_sfp19", csp9250_sfp19 }, { "csp9250_sfp20", csp9250_sfp20 }, + { "csp9250_sfp21", csp9250_sfp21 }, { "csp9250_sfp22", csp9250_sfp22 }, { "csp9250_sfp23", csp9250_sfp23 }, { "csp9250_sfp24", csp9250_sfp24 }, + { "csp9250_sfp25", csp9250_sfp25 }, { "csp9250_sfp26", csp9250_sfp26 }, { "csp9250_sfp27", csp9250_sfp27 }, { "csp9250_sfp28", csp9250_sfp28 }, + { "csp9250_sfp29", csp9250_sfp29 }, { "csp9250_sfp30", csp9250_sfp30 }, { "csp9250_sfp31", csp9250_sfp31 }, { "csp9250_sfp32", csp9250_sfp32 }, + { "csp9250_sfp33", csp9250_sfp33 }, { "csp9250_sfp34", csp9250_sfp34 }, { "csp9250_sfp35", csp9250_sfp35 }, { "csp9250_sfp36", csp9250_sfp36 }, + { "csp9250_sfp37", csp9250_sfp37 }, { "csp9250_sfp38", csp9250_sfp38 }, { "csp9250_sfp39", csp9250_sfp39 }, { "csp9250_sfp40", csp9250_sfp40 }, + { "csp9250_sfp41", csp9250_sfp41 }, { "csp9250_sfp42", csp9250_sfp42 }, { "csp9250_sfp43", csp9250_sfp43 }, { "csp9250_sfp44", csp9250_sfp44 }, + { "csp9250_sfp45", csp9250_sfp45 }, { "csp9250_sfp46", csp9250_sfp46 }, { "csp9250_sfp47", csp9250_sfp47 }, { "csp9250_sfp48", csp9250_sfp48 }, + { "csp9250_sfp49", csp9250_sfp49 }, { "csp9250_sfp50", csp9250_sfp50 }, { "csp9250_sfp51", csp9250_sfp51 }, { "csp9250_sfp52", csp9250_sfp52 }, + { "csp9250_sfp53", csp9250_sfp53 }, { "csp9250_sfp54", csp9250_sfp54 }, +#endif + { /* LIST END */ } +}; +MODULE_DEVICE_TABLE(i2c, csp9250_sfp_id); +/* Platform dependent --- */ + +/* + * list of valid port types + * note OOM_PORT_TYPE_NOT_PRESENT to indicate no + * module is present in this port + */ +typedef enum oom_driver_port_type_e { + OOM_DRIVER_PORT_TYPE_INVALID, + OOM_DRIVER_PORT_TYPE_NOT_PRESENT, + OOM_DRIVER_PORT_TYPE_SFP, + OOM_DRIVER_PORT_TYPE_SFP_PLUS, + OOM_DRIVER_PORT_TYPE_QSFP, + OOM_DRIVER_PORT_TYPE_QSFP_PLUS, + OOM_DRIVER_PORT_TYPE_QSFP28 +} oom_driver_port_type_t; + +enum driver_type_e { + DRIVER_TYPE_SFP_MSA, + DRIVER_TYPE_SFP_DDM, + DRIVER_TYPE_QSFP +}; + +/* Each client has this additional data + */ +struct eeprom_data { + char valid; /* !=0 if registers are valid */ + unsigned long last_updated; /* In jiffies */ + struct bin_attribute bin; /* eeprom data */ +}; + +struct sfp_msa_data { + char valid; /* !=0 if registers are valid */ + unsigned long last_updated; /* In jiffies */ + u64 status[6]; /* bit0:port0, bit1:port1 and so on */ + /* index 0 => tx_fail + 1 => tx_disable + 2 => rx_loss + 3 => device id + 4 => 10G Ethernet Compliance Codes + to distinguish SFP or SFP+ + 5 => DIAGNOSTIC MONITORING TYPE */ + struct eeprom_data eeprom; +}; + +struct sfp_ddm_data { + struct eeprom_data eeprom; +}; + +struct qsfp_data { + char valid; /* !=0 if registers are valid */ + unsigned long last_updated; /* In jiffies */ + u8 status[3]; /* bit0:port0, bit1:port1 and so on */ + /* index 0 => tx_fail + 1 => tx_disable + 2 => rx_loss */ + + u8 device_id; + struct eeprom_data eeprom; +}; + +struct sfp_port_data { + struct mutex update_lock; + enum driver_type_e driver_type; + int port; /* CPLD port index */ + oom_driver_port_type_t port_type; + u64 present; /* present status, bit0:port0, bit1:port1 and so on */ + + struct sfp_msa_data *msa; + struct sfp_ddm_data *ddm; + struct qsfp_data *qsfp; + + struct i2c_client *client; +}; + +static ssize_t show_port_number(struct device *dev, struct device_attribute *da, + char *buf) +{ + struct i2c_client *client = to_i2c_client(dev); + struct sfp_port_data *data = i2c_get_clientdata(client); + return sprintf(buf, "%d\n", CPLD_PORT_TO_FRONT_PORT(data->port)); +} + +/* Platform dependent +++ */ +static struct sfp_port_data *sfp_update_present(struct i2c_client *client) +{ + int i = 0, j = 0, status = -1; + u8 reg; + unsigned short cpld_addr; + struct sfp_port_data *data = i2c_get_clientdata(client); + + DEBUG_PRINT("Starting sfp present status update"); + mutex_lock(&data->update_lock); + data->present = 0; + + /* Read present status of port 1~48(SFP port) */ + for (i = 0; i < 2; i++) { + for (j = 0; j < 3; j++) { + cpld_addr = I2C_ADDR_CPLD2 + i*2; + reg = 0x9+j; + status = csp9250_i2c_cpld_read(cpld_addr, reg); + if (unlikely(status < 0)) { + dev_dbg(&client->dev, "cpld(0x%x) reg(0x%x) err %d\n", cpld_addr, reg, status); + goto exit; + } + + DEBUG_PRINT("Present status = 0x%lx\r\n", data->present); + data->present |= (u64)status << ((i*24) + (j%3)*8); + } + } + + /* Read present status of port 49-52(QSFP port) */ + cpld_addr = I2C_ADDR_CPLD2; + reg = 0x18; + status = csp9250_i2c_cpld_read(cpld_addr, reg); + + if (unlikely(status < 0)) { + dev_dbg(&client->dev, "cpld(0x%x) reg(0x%x) err %d\n", cpld_addr, reg, status); + goto exit; + } + else { + data->present |= (u64)(status & 0xF) << 48; + } + + /* Read present status of port 53-54(QSFP port) */ + cpld_addr = I2C_ADDR_CPLD3; + reg = 0x18; + status = csp9250_i2c_cpld_read(cpld_addr, reg); + + if (unlikely(status < 0)) { + dev_dbg(&client->dev, "cpld(0x%x) reg(0x%x) err %d\n", cpld_addr, reg, status); + goto exit; + } + else { + data->present |= (u64)(status & 0x3) << 52; + } + + DEBUG_PRINT("Present status = 0x%lx", data->present); + +exit: + mutex_unlock(&data->update_lock); + return (status < 0) ? ERR_PTR(status) : data; +} + +static struct sfp_port_data* sfp_update_tx_rx_status(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct sfp_port_data *data = i2c_get_clientdata(client); + int i = 0, j = 0; + int status = -1; + + if (time_before(jiffies, data->msa->last_updated + HZ + HZ / 2) && data->msa->valid) { + return data; + } + + DEBUG_PRINT("Starting csp9250 sfp tx rx status update"); + mutex_lock(&data->update_lock); + data->msa->valid = 0; + memset(data->msa->status, 0, sizeof(data->msa->status)); + + /* Read status of port 1~48(SFP port) */ + for (i = 0; i < 2; i++) { + for (j = 0; j < 9; j++) { + u8 reg; + unsigned short cpld_addr; + reg = 0xc+j; + cpld_addr = I2C_ADDR_CPLD2 + i*2; + + status = csp9250_i2c_cpld_read(cpld_addr, reg); + if (unlikely(status < 0)) { + dev_dbg(&client->dev, "cpld(0x%x) reg(0x%x) err %d\n", cpld_addr, reg, status); + goto exit; + } + + data->msa->status[j/3] |= (u64)status << ((i*24) + (j%3)*8); + } + } + + data->msa->valid = 1; + data->msa->last_updated = jiffies; + +exit: + mutex_unlock(&data->update_lock); + return (status < 0) ? ERR_PTR(status) : data; +} + +static ssize_t sfp_set_tx_disable(struct device *dev, struct device_attribute *da, + const char *buf, size_t count) +{ + struct i2c_client *client = to_i2c_client(dev); + struct sfp_port_data *data = i2c_get_clientdata(client); + unsigned short cpld_addr = 0; + u8 cpld_reg = 0, cpld_val = 0, cpld_bit = 0; + long disable; + int error; + + if (data->driver_type == DRIVER_TYPE_QSFP) { + return qsfp_set_tx_disable(dev, da, buf, count); + } + + error = kstrtol(buf, 10, &disable); + if (error) { + return error; + } + + mutex_lock(&data->update_lock); + + if(data->port < 24) { + cpld_addr = I2C_ADDR_CPLD2; + cpld_reg = 0xF + data->port / 8; + cpld_bit = 1 << (data->port % 8); + } + else { /* port 24 ~ 48 */ + cpld_addr = I2C_ADDR_CPLD3; + cpld_reg = 0xF + (data->port - 24) / 8; + cpld_bit = 1 << (data->port % 8); + } + + /* Read current status */ + cpld_val = csp9250_i2c_cpld_read(cpld_addr, cpld_reg); + + /* Update tx_disable status */ + if (disable) { + data->msa->status[1] |= BIT_INDEX(data->port); + cpld_val |= cpld_bit; + } + else { + data->msa->status[1] &= ~BIT_INDEX(data->port); + cpld_val &= ~cpld_bit; + } + + csp9250_i2c_cpld_write(cpld_addr, cpld_reg, cpld_val); + mutex_unlock(&data->update_lock); + return count; +} + +static int sfp_is_port_present(struct i2c_client *client, int port) +{ + struct sfp_port_data *data = i2c_get_clientdata(client); + + data = sfp_update_present(client); + if (IS_ERR(data)) { + + return PTR_ERR(data); + } + + return !(data->present & BIT_INDEX(data->port)); /* Platform dependent */ +} + +static ssize_t show_present(struct device *dev, struct device_attribute *da, + char *buf) +{ + struct sensor_device_attribute *attr = to_sensor_dev_attr(da); + struct i2c_client *client = to_i2c_client(dev); + + if (PRESENT_ALL == attr->index) { + int i; + u8 values[7] = {0}; + struct sfp_port_data *data = sfp_update_present(client); + + if (IS_ERR(data)) { + return PTR_ERR(data); + } + + for (i = 0; i < ARRAY_SIZE(values); i++) { + values[i] = ~(u8)(data->present >> (i * 8)); + } + + /* Return values 1 -> 54 in order */ + return sprintf(buf, "%.2x %.2x %.2x %.2x %.2x %.2x %.2x\n", + values[0], values[1], values[2], + values[3], values[4], values[5], + values[6] & 0x3F); + } + else { + struct sfp_port_data *data = i2c_get_clientdata(client); + int present = sfp_is_port_present(client, data->port); + + if (IS_ERR_VALUE(present)) { + return present; + } + /* PRESENT */ + return sprintf(buf, "%d\n", present); + } +} + +static struct sfp_port_data *sfp_update_port_type(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct sfp_port_data *data = i2c_get_clientdata(client); + u8 buf = 0; + int status; + + mutex_lock(&data->update_lock); + + switch (data->driver_type) { + case DRIVER_TYPE_SFP_MSA: + { + status = sfp_eeprom_read(client, SFF8024_PHYSICAL_DEVICE_ID_ADDR, &buf, sizeof(buf)); + if (unlikely(status < 0)) { + data->port_type = OOM_DRIVER_PORT_TYPE_INVALID; + break; + } + + if (buf != SFF8024_DEVICE_ID_SFP) { + data->port_type = OOM_DRIVER_PORT_TYPE_INVALID; + break; + } + + status = sfp_eeprom_read(client, SFF8472_10G_ETH_COMPLIANCE_ADDR, &buf, sizeof(buf)); + if (unlikely(status < 0)) { + data->port_type = OOM_DRIVER_PORT_TYPE_INVALID; + break; + } + + DEBUG_PRINT("sfp port type (0x3) data = (0x%x)", buf); + data->port_type = buf & SFF8472_10G_BASE_MASK ? OOM_DRIVER_PORT_TYPE_SFP_PLUS : OOM_DRIVER_PORT_TYPE_SFP; + break; + } + case DRIVER_TYPE_QSFP: + { + status = sfp_eeprom_read(client, SFF8024_PHYSICAL_DEVICE_ID_ADDR, &buf, sizeof(buf)); + if (unlikely(status < 0)) { + data->port_type = OOM_DRIVER_PORT_TYPE_INVALID; + break; + } + + DEBUG_PRINT("qsfp port type (0x0) buf = (0x%x)", buf); + switch (buf) { + case SFF8024_DEVICE_ID_QSFP: + data->port_type = OOM_DRIVER_PORT_TYPE_QSFP; + break; + case SFF8024_DEVICE_ID_QSFP_PLUS: + data->port_type = OOM_DRIVER_PORT_TYPE_QSFP_PLUS; + break; + case SFF8024_DEVICE_ID_QSFP28: + data->port_type = OOM_DRIVER_PORT_TYPE_QSFP_PLUS; + break; + default: + data->port_type = OOM_DRIVER_PORT_TYPE_INVALID; + break; + } + + break; + } + default: + break; + } + + mutex_unlock(&data->update_lock); + return data; +} + +static ssize_t show_port_type(struct device *dev, struct device_attribute *da, + char *buf) +{ + struct i2c_client *client = to_i2c_client(dev); + struct sfp_port_data *data = i2c_get_clientdata(client); + int present = sfp_is_port_present(client, data->port); + + if (IS_ERR_VALUE(present)) { + return present; + } + + if (!present) { + return sprintf(buf, "%d\n", OOM_DRIVER_PORT_TYPE_NOT_PRESENT); + } + + sfp_update_port_type(dev); + return sprintf(buf, "%d\n", data->port_type); +} + +static struct sfp_port_data *qsfp_update_tx_rx_status(struct device *dev) +{ + struct i2c_client *client = to_i2c_client(dev); + struct sfp_port_data *data = i2c_get_clientdata(client); + int i, status = -1; + u8 buf = 0; + u8 reg[] = {SFF8436_TX_FAULT_ADDR, SFF8436_TX_DISABLE_ADDR, SFF8436_RX_LOS_ADDR}; + + if (time_before(jiffies, data->qsfp->last_updated + HZ + HZ / 2) && data->qsfp->valid) { + return data; + } + + DEBUG_PRINT("Starting sfp tx rx status update"); + mutex_lock(&data->update_lock); + data->qsfp->valid = 0; + memset(data->qsfp->status, 0, sizeof(data->qsfp->status)); + + /* Notify device to update tx fault/ tx disable/ rx los status */ + for (i = 0; i < ARRAY_SIZE(reg); i++) { + status = sfp_eeprom_read(client, reg[i], &buf, sizeof(buf)); + if (unlikely(status < 0)) { + goto exit; + } + } + msleep(200); + + /* Read actual tx fault/ tx disable/ rx los status */ + for (i = 0; i < ARRAY_SIZE(reg); i++) { + status = sfp_eeprom_read(client, reg[i], &buf, sizeof(buf)); + if (unlikely(status < 0)) { + goto exit; + } + + DEBUG_PRINT("qsfp reg(0x%x) status = (0x%x)", reg[i], data->qsfp->status[i]); + data->qsfp->status[i] = (buf & 0xF); + } + + data->qsfp->valid = 1; + data->qsfp->last_updated = jiffies; + +exit: + mutex_unlock(&data->update_lock); + return (status < 0) ? ERR_PTR(status) : data; +} + +static ssize_t qsfp_show_tx_rx_status(struct device *dev, struct device_attribute *da, + char *buf) +{ + int present; + u8 val = 0; + struct sensor_device_attribute *attr = to_sensor_dev_attr(da); + struct i2c_client *client = to_i2c_client(dev); + struct sfp_port_data *data = i2c_get_clientdata(client); + + present = sfp_is_port_present(client, data->port); + if (IS_ERR_VALUE(present)) { + return present; + } + + if (present == 0) { + /* port is not present */ + return -ENODEV; + } + + data = qsfp_update_tx_rx_status(dev); + if (IS_ERR(data)) { + return PTR_ERR(data); + } + + switch (attr->index) { + case TX_FAULT: + val = (data->qsfp->status[2] & 0xF) ? 1 : 0; + break; + case TX_FAULT1: + case TX_FAULT2: + case TX_FAULT3: + case TX_FAULT4: + val = (data->qsfp->status[2] & BIT_INDEX(attr->index - TX_FAULT1)) ? 1 : 0; + break; + case TX_DISABLE: + val = (data->qsfp->status[1] & 0xF) ? 1 : 0; + break; + case TX_DISABLE1: + case TX_DISABLE2: + case TX_DISABLE3: + case TX_DISABLE4: + val = (data->qsfp->status[1] & BIT_INDEX(attr->index - TX_DISABLE1)) ? 1 : 0; + break; + case RX_LOS: + val = (data->qsfp->status[0] & 0xF) ? 1 : 0; + break; + case RX_LOS1: + case RX_LOS2: + case RX_LOS3: + case RX_LOS4: + val = (data->qsfp->status[0] & BIT_INDEX(attr->index - RX_LOS1)) ? 1 : 0; + break; + default: + break; + } + + return sprintf(buf, "%d\n", val); +} + +static ssize_t qsfp_set_tx_disable(struct device *dev, struct device_attribute *da, + const char *buf, size_t count) +{ + long disable; + int status; + struct sensor_device_attribute *attr = to_sensor_dev_attr(da); + struct sfp_port_data *data = NULL; + + status = kstrtol(buf, 10, &disable); + if (status) { + return status; + } + + data = qsfp_update_tx_rx_status(dev); + if (IS_ERR(data)) { + return PTR_ERR(data); + } + + mutex_lock(&data->update_lock); + + if (attr->index == TX_DISABLE) { + if (disable) { + data->qsfp->status[1] |= 0xF; + } + else { + data->qsfp->status[1] &= ~0xF; + } + } + else {/* TX_DISABLE1 ~ TX_DISABLE4*/ + if (disable) { + data->qsfp->status[1] |= (1 << (attr->index - TX_DISABLE1)); + } + else { + data->qsfp->status[1] &= ~(1 << (attr->index - TX_DISABLE1)); + } + } + + DEBUG_PRINT("index = (%d), status = (0x%x)", attr->index, data->qsfp->status[1]); + status = sfp_eeprom_write(data->client, SFF8436_TX_DISABLE_ADDR, &data->qsfp->status[1], sizeof(data->qsfp->status[1])); + if (unlikely(status < 0)) { + count = status; + } + + mutex_unlock(&data->update_lock); + return count; +} + +static ssize_t sfp_show_ddm_implemented(struct device *dev, struct device_attribute *da, + char *buf) +{ + int status; + char ddm; + struct i2c_client *client = to_i2c_client(dev); + struct sfp_port_data *data = i2c_get_clientdata(client); + + status = sfp_is_port_present(client, data->port); + if (IS_ERR_VALUE(status)) { + return status; + } + + if (status == 0) { + /* port is not present */ + return -ENODEV; + } + + status = sfp_eeprom_read(client, SFF8472_DIAG_MON_TYPE_ADDR, &ddm, sizeof(ddm)); + if (unlikely(status < 0)) { + return status; + } + + return sprintf(buf, "%d\n", (ddm & SFF8472_DIAG_MON_TYPE_DDM_MASK) ? 1 : 0); +} + +/* Platform dependent +++ */ +static ssize_t sfp_show_tx_rx_status(struct device *dev, struct device_attribute *da, + char *buf) +{ + u8 val = 0, index = 0; + struct i2c_client *client = to_i2c_client(dev); + struct sfp_port_data *data = i2c_get_clientdata(client); + struct sensor_device_attribute *attr = to_sensor_dev_attr(da); + + if (data->driver_type == DRIVER_TYPE_QSFP) { + return qsfp_show_tx_rx_status(dev, da, buf); + } + + data = sfp_update_tx_rx_status(dev); + if (IS_ERR(data)) { + return PTR_ERR(data); + } + + if(attr->index == RX_LOS_ALL) { + int i = 0; + u8 values[6] = {0}; + + for (i = 0; i < ARRAY_SIZE(values); i++) { + values[i] = (u8)(data->msa->status[2] >> (i * 8)); + } + + /** Return values 1 -> 48 in order */ + return sprintf(buf, "%.2x %.2x %.2x %.2x %.2x %.2x\n", + values[0], values[1], values[2], + values[3], values[4], values[5]); + } + + switch (attr->index) { + case TX_FAULT: + index = 0; + break; + case TX_DISABLE: + index = 1; + break; + case RX_LOS: + index = 2; + break; + default: + return 0; + } + + val = !!(data->msa->status[index] & BIT_INDEX(data->port)); + return sprintf(buf, "%d\n", val); +} +/* Platform dependent --- */ +static ssize_t sfp_eeprom_write(struct i2c_client *client, u8 command, const char *data, + int data_len) +{ +#if USE_I2C_BLOCK_READ + int status, retry = I2C_RW_RETRY_COUNT; + + if (data_len > I2C_SMBUS_BLOCK_MAX) { + data_len = I2C_SMBUS_BLOCK_MAX; + } + + while (retry) { + status = i2c_smbus_write_i2c_block_data(client, command, data_len, data); + if (unlikely(status < 0)) { + msleep(I2C_RW_RETRY_INTERVAL); + retry--; + continue; + } + + break; + } + + if (unlikely(status < 0)) { + return status; + } + + return data_len; +#else + int status, retry = I2C_RW_RETRY_COUNT; + + while (retry) { + status = i2c_smbus_write_byte_data(client, command, *data); + if (unlikely(status < 0)) { + msleep(I2C_RW_RETRY_INTERVAL); + retry--; + continue; + } + + break; + } + + if (unlikely(status < 0)) { + return status; + } + + return 1; +#endif + + +} + +static ssize_t sfp_port_write(struct sfp_port_data *data, + const char *buf, loff_t off, size_t count) +{ + ssize_t retval = 0; + + if (unlikely(!count)) { + return count; + } + + /* + * Write data to chip, protecting against concurrent updates + * from this host, but not from other I2C masters. + */ + mutex_lock(&data->update_lock); + + while (count) { + ssize_t status; + + status = sfp_eeprom_write(data->client, off, buf, count); + if (status <= 0) { + if (retval == 0) { + retval = status; + } + break; + } + buf += status; + off += status; + count -= status; + retval += status; + } + + mutex_unlock(&data->update_lock); + return retval; +} + + +static ssize_t sfp_bin_write(struct file *filp, struct kobject *kobj, + struct bin_attribute *attr, + char *buf, loff_t off, size_t count) +{ + int present; + struct sfp_port_data *data; + DEBUG_PRINT("%s(%d) offset = (%d), count = (%d)", off, count); + data = dev_get_drvdata(container_of(kobj, struct device, kobj)); + + present = sfp_is_port_present(data->client, data->port); + if (IS_ERR_VALUE(present)) { + return present; + } + + if (present == 0) { + /* port is not present */ + return -ENODEV; + } + + return sfp_port_write(data, buf, off, count); +} + +static ssize_t sfp_eeprom_read(struct i2c_client *client, u8 command, u8 *data, + int data_len) +{ +#if USE_I2C_BLOCK_READ + int status, retry = I2C_RW_RETRY_COUNT; + + if (data_len > I2C_SMBUS_BLOCK_MAX) { + data_len = I2C_SMBUS_BLOCK_MAX; + } + + while (retry) { + status = i2c_smbus_read_i2c_block_data(client, command, data_len, data); + if (unlikely(status < 0)) { + msleep(I2C_RW_RETRY_INTERVAL); + retry--; + continue; + } + + break; + } + + if (unlikely(status != data_len)) { + status = -EIO; + + goto abort; + } + +abort: + return status; +#else + int status, retry = I2C_RW_RETRY_COUNT; + + while (retry) { + status = i2c_smbus_read_byte_data(client, command); + if (unlikely(status < 0)) { + msleep(I2C_RW_RETRY_INTERVAL); + retry--; + continue; + } + + break; + } + + if (unlikely(status < 0)) { + dev_dbg(&client->dev, "sfp read byte data failed, command(0x%2x), data(0x%2x)\r\n", command, status); + + goto abort; + } + + *data = (u8)status; + status = 1; + +abort: + return status; +#endif +} + +static ssize_t sfp_port_read(struct sfp_port_data *data, + char *buf, loff_t off, size_t count) +{ + ssize_t retval = 0; + printk("acc trace %s:%d\n", __FUNCTION__, __LINE__); + if (unlikely(!count)) { + printk("acc trace %s:%d\n", __FUNCTION__, __LINE__); + DEBUG_PRINT("Count = 0, return"); + return count; + } + + /* + * Read data from chip, protecting against concurrent updates + * from this host, but not from other I2C masters. + */ + mutex_lock(&data->update_lock); + printk("acc trace %s:%d, off=0x%x,data->client->addr=0x%x\n", __FUNCTION__, __LINE__, off,data->client->addr); + while (count) { + ssize_t status; + + status = sfp_eeprom_read(data->client, off, buf, count); + if (status <= 0) { + if (retval == 0) { + retval = status; + } + printk("acc trace %s:%d\n", __FUNCTION__, __LINE__); + break; + } + + buf += status; + off += status; + count -= status; + retval += status; + } + + mutex_unlock(&data->update_lock); + return retval; + +} + +static ssize_t sfp_bin_read(struct file *filp, struct kobject *kobj, + struct bin_attribute *attr, + char *buf, loff_t off, size_t count) +{ + int present; + struct sfp_port_data *data; + DEBUG_PRINT("offset = (%d), count = (%d)", off, count); + data = dev_get_drvdata(container_of(kobj, struct device, kobj)); + printk("acc trace %s:%d, data->port=%d\n", __FUNCTION__, __LINE__, data->port); + printk("offset = (%d), count = (%d)", off, count); + present = sfp_is_port_present(data->client, data->port); + if (IS_ERR_VALUE(present)) { + return present; + } + printk("Acc trace %s:%d, present=%d\n", __FUNCTION__, __LINE__, present); + if (present == 0) { + /* port is not present */ + return -ENODEV; + } + + return sfp_port_read(data, buf, off, count); +} + +static int sfp_sysfs_eeprom_init(struct kobject *kobj, struct bin_attribute *eeprom) +{ + int err; + + sysfs_bin_attr_init(eeprom); + eeprom->attr.name = EEPROM_NAME; + eeprom->attr.mode = S_IWUSR | S_IRUGO; + eeprom->read = sfp_bin_read; + eeprom->write = sfp_bin_write; + eeprom->size = EEPROM_SIZE; + + /* Create eeprom file */ + err = sysfs_create_bin_file(kobj, eeprom); + if (err) { + return err; + } + + return 0; +} + +static int sfp_sysfs_eeprom_cleanup(struct kobject *kobj, struct bin_attribute *eeprom) +{ + sysfs_remove_bin_file(kobj, eeprom); + return 0; +} + +static const struct attribute_group sfp_msa_group = { + .attrs = sfp_msa_attributes, +}; + +static int sfp_i2c_check_functionality(struct i2c_client *client) +{ +#if USE_I2C_BLOCK_READ + return i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK); +#else + return i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA); +#endif +} + +static int sfp_msa_probe(struct i2c_client *client, const struct i2c_device_id *dev_id, + struct sfp_msa_data **data) +{ + int status; + struct sfp_msa_data *msa; + + if (!sfp_i2c_check_functionality(client)) { + status = -EIO; + goto exit; + } + + msa = kzalloc(sizeof(struct sfp_msa_data), GFP_KERNEL); + if (!msa) { + status = -ENOMEM; + goto exit; + } + + /* Register sysfs hooks */ + status = sysfs_create_group(&client->dev.kobj, &sfp_msa_group); + if (status) { + goto exit_free; + } + + /* init eeprom */ + status = sfp_sysfs_eeprom_init(&client->dev.kobj, &msa->eeprom.bin); + if (status) { + goto exit_remove; + } + + *data = msa; + dev_info(&client->dev, "sfp msa '%s'\n", client->name); + + return 0; + +exit_remove: + sysfs_remove_group(&client->dev.kobj, &sfp_msa_group); +exit_free: + kfree(msa); +exit: + + return status; +} + +static const struct attribute_group sfp_ddm_group = { + .attrs = sfp_ddm_attributes, +}; + +static int sfp_ddm_probe(struct i2c_client *client, const struct i2c_device_id *dev_id, + struct sfp_ddm_data **data) +{ + int status; + struct sfp_ddm_data *ddm; + + if (!sfp_i2c_check_functionality(client)) { + status = -EIO; + goto exit; + } + + ddm = kzalloc(sizeof(struct sfp_ddm_data), GFP_KERNEL); + if (!ddm) { + status = -ENOMEM; + goto exit; + } + + /* Register sysfs hooks */ + status = sysfs_create_group(&client->dev.kobj, &sfp_ddm_group); + if (status) { + goto exit_free; + } + + /* init eeprom */ + status = sfp_sysfs_eeprom_init(&client->dev.kobj, &ddm->eeprom.bin); + if (status) { + goto exit_remove; + } + + *data = ddm; + dev_info(&client->dev, "sfp ddm '%s'\n", client->name); + + return 0; + +exit_remove: + sysfs_remove_group(&client->dev.kobj, &sfp_ddm_group); +exit_free: + kfree(ddm); +exit: + + return status; +} + +static const struct attribute_group qsfp_group = { + .attrs = qsfp_attributes, +}; + +static int qsfp_probe(struct i2c_client *client, const struct i2c_device_id *dev_id, + struct qsfp_data **data) +{ + int status; + struct qsfp_data *qsfp; + + if (!sfp_i2c_check_functionality(client)) { + status = -EIO; + goto exit; + } + + qsfp = kzalloc(sizeof(struct qsfp_data), GFP_KERNEL); + if (!qsfp) { + status = -ENOMEM; + goto exit; + } + + /* Register sysfs hooks */ + status = sysfs_create_group(&client->dev.kobj, &qsfp_group); + if (status) { + goto exit_free; + } + + /* init eeprom */ + status = sfp_sysfs_eeprom_init(&client->dev.kobj, &qsfp->eeprom.bin); + if (status) { + goto exit_remove; + } + + *data = qsfp; + dev_info(&client->dev, "qsfp '%s'\n", client->name); + + return 0; + +exit_remove: + sysfs_remove_group(&client->dev.kobj, &qsfp_group); +exit_free: + kfree(qsfp); +exit: + + return status; +} + +static int csp9250_sfp_probe(struct i2c_client *client, + const struct i2c_device_id *dev_id) +{ + struct sfp_port_data *data = NULL; + + data = kzalloc(sizeof(struct sfp_port_data), GFP_KERNEL); + if (!data) { + return -ENOMEM; + } + + i2c_set_clientdata(client, data); + mutex_init(&data->update_lock); + data->port = dev_id->driver_data; + data->client = client; + + if (dev_id->driver_data >= csp9250_sfp1 && dev_id->driver_data <= csp9250_sfp48) { + if (client->addr == SFP_EEPROM_A0_I2C_ADDR) { + data->driver_type = DRIVER_TYPE_SFP_MSA; + return sfp_msa_probe(client, dev_id, &data->msa); + } + else if (client->addr == SFP_EEPROM_A2_I2C_ADDR) { + data->driver_type = DRIVER_TYPE_SFP_DDM; + return sfp_ddm_probe(client, dev_id, &data->ddm); + } + } + else { /* csp9250_sfp49 ~ csp9250_sfp54 */ + if (client->addr == SFP_EEPROM_A0_I2C_ADDR) { + data->driver_type = DRIVER_TYPE_QSFP; + return qsfp_probe(client, dev_id, &data->qsfp); + } + } + + return -ENODEV; +} + +static int sfp_msa_remove(struct i2c_client *client, struct sfp_msa_data *data) +{ + sfp_sysfs_eeprom_cleanup(&client->dev.kobj, &data->eeprom.bin); + sysfs_remove_group(&client->dev.kobj, &sfp_msa_group); + kfree(data); + return 0; +} + +static int sfp_ddm_remove(struct i2c_client *client, struct sfp_ddm_data *data) +{ + sfp_sysfs_eeprom_cleanup(&client->dev.kobj, &data->eeprom.bin); + sysfs_remove_group(&client->dev.kobj, &sfp_ddm_group); + kfree(data); + return 0; +} + +static int qfp_remove(struct i2c_client *client, struct qsfp_data *data) +{ + sfp_sysfs_eeprom_cleanup(&client->dev.kobj, &data->eeprom.bin); + sysfs_remove_group(&client->dev.kobj, &qsfp_group); + kfree(data); + return 0; +} + +static int csp9250_sfp_remove(struct i2c_client *client) +{ + struct sfp_port_data *data = i2c_get_clientdata(client); + + switch (data->driver_type) { + case DRIVER_TYPE_SFP_MSA: + return sfp_msa_remove(client, data->msa); + case DRIVER_TYPE_SFP_DDM: + return sfp_ddm_remove(client, data->ddm); + case DRIVER_TYPE_QSFP: + return qfp_remove(client, data->qsfp); + } + + return 0; +} + +/* Addresses scanned + */ +static const unsigned short normal_i2c[] = { I2C_CLIENT_END }; + +static struct i2c_driver sfp_driver = { + .driver = { + .name = DRIVER_NAME, + }, + .probe = csp9250_sfp_probe, + .remove = csp9250_sfp_remove, + .id_table = csp9250_sfp_id, + .address_list = normal_i2c, +}; + +static int __init csp9250_sfp_init(void) +{ + //extern int platform_accton_csp9250(void); + //if(!platform_accton_csp9250()) { + // return -ENODEV; + //} + printk("Acc trace %s\n", __FUNCTION__); + return i2c_add_driver(&sfp_driver); +} + +static void __exit csp9250_sfp_exit(void) +{ + i2c_del_driver(&sfp_driver); +} + +MODULE_AUTHOR("Brandon Chuang "); +MODULE_DESCRIPTION("accton csp9250_sfp driver"); +MODULE_LICENSE("GPL"); + +module_init(csp9250_sfp_init); +module_exit(csp9250_sfp_exit); + + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/Makefile b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/Makefile new file mode 100755 index 00000000..003238cf --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/Makefile @@ -0,0 +1 @@ +include $(ONL)/make/pkg.mk \ No newline at end of file diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/PKG.yml b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/PKG.yml new file mode 100755 index 00000000..20233ecb --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/PKG.yml @@ -0,0 +1 @@ +!include $ONL_TEMPLATES/onlp-platform-any.yml PLATFORM=x86-64-accton-csp9250 ARCH=amd64 TOOLCHAIN=x86_64-linux-gnu diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/Makefile b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/Makefile new file mode 100755 index 00000000..e7437cb2 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/Makefile @@ -0,0 +1,2 @@ +FILTER=src +include $(ONL)/make/subdirs.mk diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/lib/Makefile b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/lib/Makefile new file mode 100755 index 00000000..bdf072c1 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/lib/Makefile @@ -0,0 +1,45 @@ +############################################################ +# +# +# Copyright 2014 BigSwitch Networks, Inc. +# +# Licensed under the Eclipse Public License, Version 1.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.eclipse.org/legal/epl-v10.html +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, +# either express or implied. See the License for the specific +# language governing permissions and limitations under the +# License. +# +# +############################################################ +# +# +############################################################ +include $(ONL)/make/config.amd64.mk + +MODULE := libonlp-x86-64-accton-csp9250 +include $(BUILDER)/standardinit.mk + +DEPENDMODULES := AIM IOF x86_64_accton_csp9250 onlplib +DEPENDMODULE_HEADERS := sff + +include $(BUILDER)/dependmodules.mk + +SHAREDLIB := libonlp-x86-64-accton-csp9250.so +$(SHAREDLIB)_TARGETS := $(ALL_TARGETS) +include $(BUILDER)/so.mk +.DEFAULT_GOAL := $(SHAREDLIB) + +GLOBAL_CFLAGS += -I$(onlp_BASEDIR)/module/inc +GLOBAL_CFLAGS += -DAIM_CONFIG_INCLUDE_MODULES_INIT=1 +GLOBAL_CFLAGS += -fPIC +GLOBAL_LINK_LIBS += -lpthread + +include $(BUILDER)/targets.mk + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/onlpdump/Makefile b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/onlpdump/Makefile new file mode 100755 index 00000000..78e0ca0a --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/onlpdump/Makefile @@ -0,0 +1,46 @@ +############################################################ +# +# +# Copyright 2014 BigSwitch Networks, Inc. +# +# Licensed under the Eclipse Public License, Version 1.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.eclipse.org/legal/epl-v10.html +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, +# either express or implied. See the License for the specific +# language governing permissions and limitations under the +# License. +# +# +############################################################ +# +# +# +############################################################ +include $(ONL)/make/config.amd64.mk + +.DEFAULT_GOAL := onlpdump + +MODULE := onlpdump +include $(BUILDER)/standardinit.mk + +DEPENDMODULES := AIM IOF onlp x86_64_accton_csp9250 onlplib onlp_platform_defaults sff cjson cjson_util timer_wheel OS + +include $(BUILDER)/dependmodules.mk + +BINARY := onlpdump +$(BINARY)_LIBRARIES := $(LIBRARY_TARGETS) +include $(BUILDER)/bin.mk + +GLOBAL_CFLAGS += -DAIM_CONFIG_AIM_MAIN_FUNCTION=onlpdump_main +GLOBAL_CFLAGS += -DAIM_CONFIG_INCLUDE_MODULES_INIT=1 +GLOBAL_CFLAGS += -DAIM_CONFIG_INCLUDE_MAIN=1 +GLOBAL_LINK_LIBS += -lpthread -lm + +include $(BUILDER)/targets.mk + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/.module b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/.module new file mode 100755 index 00000000..e0797bf3 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/.module @@ -0,0 +1 @@ +name: x86_64_accton_csp9250 diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/Makefile b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/Makefile new file mode 100755 index 00000000..5d0c54b2 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/Makefile @@ -0,0 +1,9 @@ +############################################################################### +# +# +# +############################################################################### +include ../../init.mk +MODULE := x86_64_accton_csp9250 +AUTOMODULE := x86_64_accton_csp9250 +include $(BUILDER)/definemodule.mk diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/README b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/README new file mode 100755 index 00000000..9a62ecfc --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/README @@ -0,0 +1,6 @@ +############################################################################### +# +# x86_64_accton_csp9250 README +# +############################################################################### + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/auto/make.mk b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/auto/make.mk new file mode 100755 index 00000000..f349d340 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/auto/make.mk @@ -0,0 +1,9 @@ +############################################################################### +# +# x86_64_accton_csp9250 Autogeneration +# +############################################################################### +x86_64_accton_csp9250_AUTO_DEFS := module/auto/x86_64_accton_csp9250.yml +x86_64_accton_csp9250_AUTO_DIRS := module/inc/x86_64_accton_csp9250 module/src +include $(BUILDER)/auto.mk + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/auto/x86_64_accton_csp9250.yml b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/auto/x86_64_accton_csp9250.yml new file mode 100755 index 00000000..227f3670 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/auto/x86_64_accton_csp9250.yml @@ -0,0 +1,50 @@ +############################################################################### +# +# x86_64_accton_csp9250 Autogeneration Definitions. +# +############################################################################### + +cdefs: &cdefs +- x86_64_accton_csp9250_CONFIG_INCLUDE_LOGGING: + doc: "Include or exclude logging." + default: 1 +- x86_64_accton_csp9250_CONFIG_LOG_OPTIONS_DEFAULT: + doc: "Default enabled log options." + default: AIM_LOG_OPTIONS_DEFAULT +- x86_64_accton_csp9250_CONFIG_LOG_BITS_DEFAULT: + doc: "Default enabled log bits." + default: AIM_LOG_BITS_DEFAULT +- x86_64_accton_csp9250_CONFIG_LOG_CUSTOM_BITS_DEFAULT: + doc: "Default enabled custom log bits." + default: 0 +- x86_64_accton_csp9250_CONFIG_PORTING_STDLIB: + doc: "Default all porting macros to use the C standard libraries." + default: 1 +- x86_64_accton_csp9250_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS: + doc: "Include standard library headers for stdlib porting macros." + default: x86_64_accton_csp9250_CONFIG_PORTING_STDLIB +- x86_64_accton_csp9250_CONFIG_INCLUDE_UCLI: + doc: "Include generic uCli support." + default: 0 +- x86_64_accton_csp9250_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION: + doc: "Assume chassis fan direction is the same as the PSU fan direction." + default: 0 + + +definitions: + cdefs: + x86_64_accton_csp9250_CONFIG_HEADER: + defs: *cdefs + basename: x86_64_accton_csp9250_config + + portingmacro: + x86_64_accton_csp9250: + macros: + - malloc + - free + - memset + - memcpy + - strncpy + - vsnprintf + - snprintf + - strlen diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250.x b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250.x new file mode 100755 index 00000000..9efed291 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250.x @@ -0,0 +1,14 @@ +/**************************************************************************//** + * + * + * + *****************************************************************************/ +#include + +/* <--auto.start.xmacro(ALL).define> */ +/* */ + +/* <--auto.start.xenum(ALL).define> */ +/* */ + + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250_config.h b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250_config.h new file mode 100755 index 00000000..142f9e22 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250_config.h @@ -0,0 +1,137 @@ +/**************************************************************************//** + * + * @file + * @brief x86_64_accton_csp9250 Configuration Header + * + * @addtogroup x86_64_accton_csp9250-config + * @{ + * + *****************************************************************************/ +#ifndef __x86_64_accton_csp9250_CONFIG_H__ +#define __x86_64_accton_csp9250_CONFIG_H__ + +#ifdef GLOBAL_INCLUDE_CUSTOM_CONFIG +#include +#endif +#ifdef x86_64_accton_csp9250_INCLUDE_CUSTOM_CONFIG +#include +#endif + +/* */ +#include +/** + * x86_64_accton_csp9250_CONFIG_INCLUDE_LOGGING + * + * Include or exclude logging. */ + + +#ifndef x86_64_accton_csp9250_CONFIG_INCLUDE_LOGGING +#define x86_64_accton_csp9250_CONFIG_INCLUDE_LOGGING 1 +#endif + +/** + * x86_64_accton_csp9250_CONFIG_LOG_OPTIONS_DEFAULT + * + * Default enabled log options. */ + + +#ifndef x86_64_accton_csp9250_CONFIG_LOG_OPTIONS_DEFAULT +#define x86_64_accton_csp9250_CONFIG_LOG_OPTIONS_DEFAULT AIM_LOG_OPTIONS_DEFAULT +#endif + +/** + * x86_64_accton_csp9250_CONFIG_LOG_BITS_DEFAULT + * + * Default enabled log bits. */ + + +#ifndef x86_64_accton_csp9250_CONFIG_LOG_BITS_DEFAULT +#define x86_64_accton_csp9250_CONFIG_LOG_BITS_DEFAULT AIM_LOG_BITS_DEFAULT +#endif + +/** + * x86_64_accton_csp9250_CONFIG_LOG_CUSTOM_BITS_DEFAULT + * + * Default enabled custom log bits. */ + + +#ifndef x86_64_accton_csp9250_CONFIG_LOG_CUSTOM_BITS_DEFAULT +#define x86_64_accton_csp9250_CONFIG_LOG_CUSTOM_BITS_DEFAULT 0 +#endif + +/** + * x86_64_accton_csp9250_CONFIG_PORTING_STDLIB + * + * Default all porting macros to use the C standard libraries. */ + + +#ifndef x86_64_accton_csp9250_CONFIG_PORTING_STDLIB +#define x86_64_accton_csp9250_CONFIG_PORTING_STDLIB 1 +#endif + +/** + * x86_64_accton_csp9250_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS + * + * Include standard library headers for stdlib porting macros. */ + + +#ifndef x86_64_accton_csp9250_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS +#define x86_64_accton_csp9250_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS x86_64_accton_as5512_54x_CONFIG_PORTING_STDLIB +#endif + +/** + * x86_64_accton_csp9250_CONFIG_INCLUDE_UCLI + * + * Include generic uCli support. */ + + +#ifndef x86_64_accton_csp9250_CONFIG_INCLUDE_UCLI +#define x86_64_accton_csp9250_CONFIG_INCLUDE_UCLI 0 +#endif + +/** + * x86_64_accton_csp9250_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION + * + * Assume chassis fan direction is the same as the PSU fan direction. */ + + +#ifndef x86_64_accton_csp9250_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION +#define x86_64_accton_csp9250_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION 0 +#endif + + + +/** + * All compile time options can be queried or displayed + */ + +/** Configuration settings structure. */ +typedef struct x86_64_accton_csp9250_config_settings_s { + /** name */ + const char* name; + /** value */ + const char* value; +} x86_64_accton_csp9250_config_settings_t; + +/** Configuration settings table. */ +/** x86_64_accton_csp9250_config_settings table. */ +extern x86_64_accton_csp9250_config_settings_t x86_64_accton_csp9250_config_settings[]; + +/** + * @brief Lookup a configuration setting. + * @param setting The name of the configuration option to lookup. + */ +const char* x86_64_accton_csp9250_config_lookup(const char* setting); + +/** + * @brief Show the compile-time configuration. + * @param pvs The output stream. + */ +int x86_64_accton_csp9250_config_show(struct aim_pvs_s* pvs); + +/* */ + +#include "x86_64_accton_csp9250_porting.h" + +#endif /* __x86_64_accton_csp9250_CONFIG_H__ */ +/* @} */ diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250_dox.h b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250_dox.h new file mode 100755 index 00000000..72bb34c9 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250_dox.h @@ -0,0 +1,26 @@ +/**************************************************************************//** + * + * x86_64_accton_csp9250 Doxygen Header + * + *****************************************************************************/ +#ifndef __x86_64_accton_csp9250_DOX_H__ +#define __x86_64_accton_csp9250_DOX_H__ + +/** + * @defgroup x86_64_accton_csp9250 x86_64_accton_csp9250 - x86_64_accton_csp9250 Description + * + +The documentation overview for this module should go here. + + * + * @{ + * + * @defgroup x86_64_accton_csp9250-x86_64_accton_csp9250 Public Interface + * @defgroup x86_64_accton_csp9250-config Compile Time Configuration + * @defgroup x86_64_accton_csp9250-porting Porting Macros + * + * @} + * + */ + +#endif /* __x86_64_accton_csp9250_DOX_H__ */ diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250_porting.h b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250_porting.h new file mode 100755 index 00000000..c5ecbb13 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/inc/x86_64_accton_csp9250/x86_64_accton_csp9250_porting.h @@ -0,0 +1,107 @@ +/**************************************************************************//** + * + * @file + * @brief x86_64_accton_csp9250 Porting Macros. + * + * @addtogroup x86_64_accton_csp9250-porting + * @{ + * + *****************************************************************************/ +#ifndef __x86_64_accton_csp9250_PORTING_H__ +#define __x86_64_accton_csp9250_PORTING_H__ + + +/* */ +#if x86_64_accton_csp9250_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS == 1 +#include +#include +#include +#include +#include +#endif + +#ifndef x86_64_accton_csp9250_MALLOC + #if defined(GLOBAL_MALLOC) + #define x86_64_accton_csp9250_MALLOC GLOBAL_MALLOC + #elif x86_64_accton_csp9250_CONFIG_PORTING_STDLIB == 1 + #define x86_64_accton_csp9250_MALLOC malloc + #else + #error The macro x86_64_accton_csp9250_MALLOC is required but cannot be defined. + #endif +#endif + +#ifndef x86_64_accton_csp9250_FREE + #if defined(GLOBAL_FREE) + #define x86_64_accton_csp9250_FREE GLOBAL_FREE + #elif x86_64_accton_csp9250_CONFIG_PORTING_STDLIB == 1 + #define x86_64_accton_csp9250_FREE free + #else + #error The macro x86_64_accton_csp9250_FREE is required but cannot be defined. + #endif +#endif + +#ifndef x86_64_accton_csp9250_MEMSET + #if defined(GLOBAL_MEMSET) + #define x86_64_accton_csp9250_MEMSET GLOBAL_MEMSET + #elif x86_64_accton_csp9250_CONFIG_PORTING_STDLIB == 1 + #define x86_64_accton_csp9250_MEMSET memset + #else + #error The macro x86_64_accton_csp9250_MEMSET is required but cannot be defined. + #endif +#endif + +#ifndef x86_64_accton_csp9250_MEMCPY + #if defined(GLOBAL_MEMCPY) + #define x86_64_accton_csp9250_MEMCPY GLOBAL_MEMCPY + #elif x86_64_accton_csp9250_CONFIG_PORTING_STDLIB == 1 + #define x86_64_accton_csp9250_MEMCPY memcpy + #else + #error The macro x86_64_accton_csp9250_MEMCPY is required but cannot be defined. + #endif +#endif + +#ifndef x86_64_accton_csp9250_STRNCPY + #if defined(GLOBAL_STRNCPY) + #define x86_64_accton_csp9250_STRNCPY GLOBAL_STRNCPY + #elif x86_64_accton_csp9250_CONFIG_PORTING_STDLIB == 1 + #define x86_64_accton_csp9250_STRNCPY strncpy + #else + #error The macro x86_64_accton_csp9250_STRNCPY is required but cannot be defined. + #endif +#endif + +#ifndef x86_64_accton_csp9250_VSNPRINTF + #if defined(GLOBAL_VSNPRINTF) + #define x86_64_accton_csp9250_VSNPRINTF GLOBAL_VSNPRINTF + #elif x86_64_accton_csp9250_CONFIG_PORTING_STDLIB == 1 + #define x86_64_accton_csp9250_VSNPRINTF vsnprintf + #else + #error The macro x86_64_accton_csp9250_VSNPRINTF is required but cannot be defined. + #endif +#endif + +#ifndef x86_64_accton_csp9250_SNPRINTF + #if defined(GLOBAL_SNPRINTF) + #define x86_64_accton_csp9250_SNPRINTF GLOBAL_SNPRINTF + #elif x86_64_accton_csp9250_CONFIG_PORTING_STDLIB == 1 + #define x86_64_accton_csp9250_SNPRINTF snprintf + #else + #error The macro x86_64_accton_csp9250_SNPRINTF is required but cannot be defined. + #endif +#endif + +#ifndef x86_64_accton_csp9250_STRLEN + #if defined(GLOBAL_STRLEN) + #define x86_64_accton_csp9250_STRLEN GLOBAL_STRLEN + #elif x86_64_accton_csp9250_CONFIG_PORTING_STDLIB == 1 + #define x86_64_accton_csp9250_STRLEN strlen + #else + #error The macro x86_64_accton_csp9250_STRLEN is required but cannot be defined. + #endif +#endif + +/* */ + + +#endif /* __x86_64_accton_csp9250_PORTING_H__ */ +/* @} */ diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/make.mk b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/make.mk new file mode 100755 index 00000000..b7da4aa9 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/make.mk @@ -0,0 +1,10 @@ +############################################################################### +# +# +# +############################################################################### +THIS_DIR := $(dir $(lastword $(MAKEFILE_LIST))) +x86_64_accton_csp9250_INCLUDES := -I $(THIS_DIR)inc +x86_64_accton_csp9250_INTERNAL_INCLUDES := -I $(THIS_DIR)src +x86_64_accton_csp9250_DEPENDMODULE_ENTRIES := init:x86_64_accton_csp9250 ucli:x86_64_accton_csp9250 + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/Makefile b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/Makefile new file mode 100755 index 00000000..d4010caa --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/Makefile @@ -0,0 +1,9 @@ +############################################################################### +# +# Local source generation targets. +# +############################################################################### + +ucli: + @../../../../tools/uclihandlers.py x86_64_accton_csp9250.c + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/debug.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/debug.c new file mode 100755 index 00000000..2c01a6b3 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/debug.c @@ -0,0 +1,45 @@ +#include "x86_64_accton_csp9250_int.h" + +#if x86_64_accton_csp9250_CONFIG_INCLUDE_DEBUG == 1 + +#include + +static char help__[] = + "Usage: debug [options]\n" + " -c CPLD Versions\n" + " -h Help\n" + ; + +int +x86_64_accton_csp9250_debug_main(int argc, char* argv[]) +{ + int c = 0; + int help = 0; + int rv = 0; + + while( (c = getopt(argc, argv, "ch")) != -1) { + switch(c) + { + case 'c': c = 1; break; + case 'h': help = 1; rv = 0; break; + default: help = 1; rv = 1; break; + } + + } + + if(help || argc == 1) { + printf("%s", help__); + return rv; + } + + if(c) { + printf("Not implemented.\n"); + } + + + return 0; +} + +#endif + + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/fani.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/fani.c new file mode 100755 index 00000000..3b667e52 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/fani.c @@ -0,0 +1,423 @@ +/************************************************************ + * + * + * Copyright 2014 Big Switch Networks, Inc. + * Copyright 2014 Accton Technology Corporation. + * + * Licensed under the Eclipse Public License, Version 1.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.eclipse.org/legal/epl-v10.html + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the + * License. + * + * + ************************************************************ + * + * Fan Platform Implementation Defaults. + * + ***********************************************************/ +#include +#include +#include +#include "platform_lib.h" + +#define MAX_FAN_1_SPEED 21500 +#define MAX_FAN_2_SPEED 18000 + +#define MAX_PSU_FAN_SPEED 25500 + +#define FAN_MAX_LENGTH 256 +#define FAN_LEAVE_NUM 2 + +#define FAN_IPMI_TMP_FILE_RM_RPM "rm -f /tmp/fan_bmc_info_rpm > /dev/null 2>&1" +#define FAN_IPMI_TMP_FILE_RM_PERCENT "rm -f /tmp/fan_bmc_info_rpm_percent > /dev/null 2>&1" + +#define FAN_IPMI_TMP_FILE_RPM "/tmp/fan_bmc_info_rpm" +#define FAN_IPMI_TMP_FILE_PERCENT "/tmp/fan_bmc_info_percent" + +#define FAN_IPMI_TMP_FILE_FIND_NO_READ "No Reading" +#define FAN_IPMI_TMP_FILE_FIND "RPM" +#define FAN_IPMI_TMP_FILE_FIND_PERCENT "02" + +#define FAN_IPMI_SDR_CMD "ipmitool sdr list" +#define FAN_IPMI_PWM_SET "ipmitool raw 0x34 0xaa 0x5a 0x54 0x40 0x04 0x01 0xff" +#define FAN_IPMI_PWM_GET "ipmitool raw 0x34 0xaa 0x5a 0x54 0x40 0x04 0x02 0x01" +#define FAN_IPMI_SDR_FILE "/usr/bin/fan_bmc_sdr" +#define FAN_IPMI_SDR_FILE_RM "rm -f /usr/bin/fan_bmc_sdr > /dev/null 2>&1" +#define FAN_CHECK_TIME "/usr/bin/fan_check_time" +#define FAN_IPMI_PWM_FILE "/usr/bin/fan_bmc_pwm" +#define FAN_IPMI_PWM_FILE_RM "rm -f /usr/bin/fan_bmc_pwm > /dev/null 2>&1" + +#define FAN_CAN_SET_IPMI_TIME 5 + +enum fan_id { + FAN_1_ON_FAN_BOARD = 1, + FAN_2_ON_FAN_BOARD, + FAN_3_ON_FAN_BOARD, + FAN_4_ON_FAN_BOARD, + FAN_5_ON_FAN_BOARD, +}; + +#define CHASSIS_FAN_INFO(fid) \ + { \ + { ONLP_FAN_ID_CREATE(FAN_##fid##_ON_FAN_BOARD), "Fan - "#fid, 0 },\ + 0x0,\ + ONLP_FAN_CAPS_SET_PERCENTAGE | ONLP_FAN_CAPS_GET_RPM | ONLP_FAN_CAPS_GET_PERCENTAGE,\ + 0,\ + 0,\ + ONLP_FAN_MODE_INVALID,\ + } + + +#define PSU_FAN_INFO(pid, fid) \ + { \ + { ONLP_FAN_ID_CREATE(FAN_##fid##_ON_PSU_##pid), "PSU "#pid" - Fan "#fid, 0 },\ + 0x0,\ + ONLP_FAN_CAPS_SET_PERCENTAGE | ONLP_FAN_CAPS_GET_RPM | ONLP_FAN_CAPS_GET_PERCENTAGE,\ + 0,\ + 0,\ + ONLP_FAN_MODE_INVALID,\ + } + +/* Static fan information */ +onlp_fan_info_t finfo[] = { + { }, /* Not used */ + CHASSIS_FAN_INFO(1), + CHASSIS_FAN_INFO(2), + CHASSIS_FAN_INFO(3), + CHASSIS_FAN_INFO(4), + CHASSIS_FAN_INFO(5) +}; + + + +typedef struct onlp_fan_dev_s +{ + int fan_id; + char *tag[FAN_LEAVE_NUM]; + +}onlp_fan_dev_t; + + +onlp_fan_dev_t fan_sensor_table[]= +{ + {0, {NULL, NULL}}, + {FAN_1_ON_FAN_BOARD, {"Fan1_1", "Fan1_2"}}, + {FAN_2_ON_FAN_BOARD, {"Fan2_1", "Fan2_2"}}, + {FAN_3_ON_FAN_BOARD, {"Fan3_1", "Fan3_2"}}, + {FAN_4_ON_FAN_BOARD, {"Fan4_1", "Fan4_2"}}, + {FAN_5_ON_FAN_BOARD, {"Fan5_1", "Fan5_2"}}, +}; + + + +#define VALIDATE(_id) \ + do { \ + if(!ONLP_OID_IS_FAN(_id)) { \ + return ONLP_STATUS_E_INVALID; \ + } \ + } while(0) + + +static int +fani_time_exist(void) +{ + struct stat file_info; + if(stat(FAN_CHECK_TIME ,&file_info)==0) + { + if(file_info.st_size==0) + return 0; + return 1; + } + else + return 1; +} +static int +fani_sdr_file_exist(void) +{ + struct stat file_info; + if(stat(FAN_IPMI_SDR_FILE ,&file_info)==0) + { + if(file_info.st_size==0) + return 0; + return 1; + } + else + return 0; +} + + +static int +_onlp_fani_info_get_fan(int fid, onlp_fan_info_t* info) +{ + int i, size; + char *tag, *p; + char cmd[FAN_MAX_LENGTH/2]={0}; + char fan_val_str[6]={0}; + int fan_val_int=0; + uint8_t data[FAN_MAX_LENGTH] = {0}; + struct timeval new_tv; + long last_time; + int get_data_by_ipmi=0; + + if(fid > FAN_5_ON_FAN_BOARD) + return ONLP_STATUS_E_INTERNAL; + + if(fani_time_exist()) + { + if(onlp_file_read(data, FAN_MAX_LENGTH, &size, FAN_CHECK_TIME)!=ONLP_STATUS_OK) + { + last_time=0; + } + else + last_time = atol((char*)data); + } + else + last_time=0; + + gettimeofday(&new_tv,NULL); + + if(last_time==0) /* first time */ + { + get_data_by_ipmi=1; + } + else + { + if(new_tv.tv_sec > last_time) + { + if((new_tv.tv_sec - last_time) > FAN_CAN_SET_IPMI_TIME) + { + get_data_by_ipmi=1; + } + else + get_data_by_ipmi=0; + } + else if(new_tv.tv_sec == last_time) + get_data_by_ipmi=0; + else + get_data_by_ipmi=1; + + } + memset(data ,0x0, FAN_MAX_LENGTH); + snprintf((char*)data, FAN_MAX_LENGTH-1, "%ld", new_tv.tv_sec); + if(onlp_file_write_str((char*)data, FAN_CHECK_TIME)!=ONLP_STATUS_OK) + { + return ONLP_STATUS_E_INTERNAL; + } + + if(get_data_by_ipmi || !fani_sdr_file_exist()) /* Set ipmitool cmd to get all data and save to file*/ + { + /* set ipmi sdr cmd to get rpm */ + snprintf(cmd, (FAN_MAX_LENGTH/2) -1, "%s > %s ", FAN_IPMI_SDR_CMD, FAN_IPMI_SDR_FILE); + system(cmd); + /* set ipmi cmd to get pwm */ + snprintf(cmd, (FAN_MAX_LENGTH/2) -1, "%s > %s ", FAN_IPMI_PWM_GET, FAN_IPMI_PWM_FILE); + system(cmd); + fflush(stdout); + } + for(i=0; i %s", FAN_IPMI_SDR_FILE, tag, FAN_IPMI_TMP_FILE_RPM); + system(cmd); + + if(onlp_file_read(data, FAN_MAX_LENGTH, &size, FAN_IPMI_TMP_FILE_RPM)!=ONLP_STATUS_OK) + { + return ONLP_STATUS_E_INTERNAL; + } + p=strstr((char*)data, FAN_IPMI_TMP_FILE_FIND); + if(p==NULL) + { + return ONLP_STATUS_E_INTERNAL; + } + if(((uint8_t*)p-data) < sizeof(fan_val_str)/sizeof(char)) + { + return ONLP_STATUS_E_INTERNAL; + } + fan_val_str[0]=(data[(uint8_t*)p-data-6]=='|' || data[(uint8_t*)p-data-6]==' ')?'0':data[(uint8_t*)p-data-6]; + fan_val_str[1]=(data[(uint8_t*)p-data-5]=='|' || data[(uint8_t*)p-data-5]==' ')?'0':data[(uint8_t*)p-data-5]; + fan_val_str[2]=(data[(uint8_t*)p-data-4]=='|' || data[(uint8_t*)p-data-4]==' ')?'0':data[(uint8_t*)p-data-4]; + fan_val_str[3]=(data[(uint8_t*)p-data-3]=='|' || data[(uint8_t*)p-data-3]==' ')?'0':data[(uint8_t*)p-data-3]; + fan_val_str[4]=(data[(uint8_t*)p-data-2]=='|' || data[(uint8_t*)p-data-2]==' ')?'0':data[(uint8_t*)p-data-2]; + /* take the min value from front/rear fan speed + */ + if(!fan_val_int) + { + if(fan_val_int < ONLPLIB_ATOI(fan_val_str)) + { + fan_val_int=ONLPLIB_ATOI(fan_val_str); + } + } + else + fan_val_int=ONLPLIB_ATOI(fan_val_str); + } + + if(fan_val_int==0) + { + info->status &= ~ONLP_FAN_STATUS_PRESENT; + return ONLP_STATUS_OK; + } + info->rpm=fan_val_int; + info->percentage=0; + snprintf(cmd , (FAN_MAX_LENGTH/2)-1, "cat %s > %s", FAN_IPMI_PWM_FILE, FAN_IPMI_TMP_FILE_PERCENT); + system(cmd); + + if(onlp_file_read(data, FAN_MAX_LENGTH, &size, FAN_IPMI_TMP_FILE_PERCENT)!=ONLP_STATUS_OK) + { + return ONLP_STATUS_E_INTERNAL; + } + p=strstr((char*)data, FAN_IPMI_TMP_FILE_FIND_PERCENT); + if(p==NULL) + { + return ONLP_STATUS_E_INTERNAL; + } + if(((uint8_t*)p-data) < sizeof(fan_val_str)/sizeof(char)) + { + return ONLP_STATUS_E_INTERNAL; + } + memset(fan_val_str, 0x0, sizeof(fan_val_str)); + fan_val_str[0]=data[(uint8_t*)p-data+3]; + fan_val_str[1]=data[(uint8_t*)p-data+4]; + info->percentage = ONLPLIB_ATOI(fan_val_str); + + info->status |= ONLP_FAN_STATUS_PRESENT; + + return ONLP_STATUS_OK; +} + +/* + * This function will be called prior to all of onlp_fani_* functions. + */ +int +onlp_fani_init(void) +{ + char cmd[FAN_MAX_LENGTH/2] = {0}; + + snprintf(cmd, (FAN_MAX_LENGTH/2) -1, "echo 0 > %s ", FAN_CHECK_TIME); + system(cmd); + return ONLP_STATUS_OK; + +} + +int +onlp_fani_info_get(onlp_oid_t id, onlp_fan_info_t* info) +{ + int rc = 0; + int fid; + VALIDATE(id); + + fid = ONLP_OID_ID_GET(id); + *info = finfo[fid]; + + switch (fid) + { + case FAN_1_ON_FAN_BOARD: + case FAN_2_ON_FAN_BOARD: + case FAN_3_ON_FAN_BOARD: + case FAN_4_ON_FAN_BOARD: + case FAN_5_ON_FAN_BOARD: + rc =_onlp_fani_info_get_fan(fid, info); + break; + default: + rc = ONLP_STATUS_E_INVALID; + break; + } + + return rc; +} + +/* + * This function sets the speed of the given fan in RPM. + * + * This function will only be called if the fan supprots the RPM_SET + * capability. + * + * It is optional if you have no fans at all with this feature. + */ +int +onlp_fani_rpm_set(onlp_oid_t id, int rpm) +{ + return ONLP_STATUS_E_UNSUPPORTED; +} + +/* + * This function sets the fan speed of the given OID as a percentage. + * + * This will only be called if the OID has the PERCENTAGE_SET + * capability. + * + * It is optional if you have no fans at all with this feature. + */ +int +onlp_fani_percentage_set(onlp_oid_t id, int p) +{ + int fid; + char cmd[FAN_MAX_LENGTH/2]={0}; + + VALIDATE(id); + + fid = ONLP_OID_ID_GET(id); + + + switch (fid) + { + case FAN_1_ON_FAN_BOARD: + case FAN_2_ON_FAN_BOARD: + case FAN_3_ON_FAN_BOARD: + case FAN_4_ON_FAN_BOARD: + case FAN_5_ON_FAN_BOARD: + break; + default: + return ONLP_STATUS_E_INVALID; + } + + snprintf(cmd,FAN_MAX_LENGTH/2, "%s %d > /dev/null 2>&1", FAN_IPMI_PWM_SET, p); + system(cmd); + + return ONLP_STATUS_OK; +} + + +/* + * This function sets the fan speed of the given OID as per + * the predefined ONLP fan speed modes: off, slow, normal, fast, max. + * + * Interpretation of these modes is up to the platform. + * + */ +int +onlp_fani_mode_set(onlp_oid_t id, onlp_fan_mode_t mode) +{ + return ONLP_STATUS_E_UNSUPPORTED; +} + +/* + * This function sets the fan direction of the given OID. + * + * This function is only relevant if the fan OID supports both direction + * capabilities. + * + * This function is optional unless the functionality is available. + */ +int +onlp_fani_dir_set(onlp_oid_t id, onlp_fan_dir_t dir) +{ + return ONLP_STATUS_E_UNSUPPORTED; +} + +/* + * Generic fan ioctl. Optional. + */ +int +onlp_fani_ioctl(onlp_oid_t id, va_list vargs) +{ + return ONLP_STATUS_E_UNSUPPORTED; +} + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/ledi.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/ledi.c new file mode 100755 index 00000000..17f4bb29 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/ledi.c @@ -0,0 +1,261 @@ +/************************************************************ + * + * + * Copyright 2014 Big Switch Networks, Inc. + * Copyright 2014 Accton Technology Corporation. + * + * Licensed under the Eclipse Public License, Version 1.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.eclipse.org/legal/epl-v10.html + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the + * License. + * + * + ************************************************************ + * + * + * + ***********************************************************/ +#include +#include +#include +#include +#include +#include + +#include "platform_lib.h" + +#define prefix_path "/sys/class/leds/accton_csp9250_led::" +#define filename "brightness" + +#define VALIDATE(_id) \ + do { \ + if(!ONLP_OID_IS_LED(_id)) { \ + return ONLP_STATUS_E_INVALID; \ + } \ + } while(0) + +/* LED related data + */ +enum onlp_led_id +{ + LED_RESERVED = 0, + LED_DIAG, + LED_LOC, + LED_FAN, + LED_PSU1, + LED_PSU2 +}; + +enum led_light_mode { + LED_MODE_OFF = 0, + LED_MODE_GREEN, + LED_MODE_AMBER, + LED_MODE_RED, + LED_MODE_BLUE, + LED_MODE_GREEN_BLINK, + LED_MODE_AMBER_BLINK, + LED_MODE_RED_BLINK, + LED_MODE_BLUE_BLINK, + LED_MODE_AUTO, + LED_MODE_UNKNOWN +}; + +typedef struct led_light_mode_map { + enum onlp_led_id id; + enum led_light_mode driver_led_mode; + enum onlp_led_mode_e onlp_led_mode; +} led_light_mode_map_t; + +led_light_mode_map_t led_map[] = { +{LED_DIAG, LED_MODE_OFF, ONLP_LED_MODE_OFF}, +{LED_DIAG, LED_MODE_GREEN, ONLP_LED_MODE_GREEN}, +{LED_DIAG, LED_MODE_AMBER, ONLP_LED_MODE_ORANGE}, +{LED_DIAG, LED_MODE_RED, ONLP_LED_MODE_RED}, +{LED_LOC, LED_MODE_OFF, ONLP_LED_MODE_OFF}, +{LED_LOC, LED_MODE_BLUE, ONLP_LED_MODE_BLUE}, +{LED_FAN, LED_MODE_AUTO, ONLP_LED_MODE_AUTO}, +{LED_PSU1, LED_MODE_AUTO, ONLP_LED_MODE_AUTO}, +{LED_PSU2, LED_MODE_AUTO, ONLP_LED_MODE_AUTO} +}; + +static char last_path[][10] = /* must map with onlp_led_id */ +{ + "reserved", + "diag", + "loc", + "fan", + "psu1", + "psu2" +}; + +/* + * Get the information for the given LED OID. + */ +static onlp_led_info_t linfo[] = +{ + { }, /* Not used */ + { + { ONLP_LED_ID_CREATE(LED_DIAG), "LED 1 (DIAG LED)", 0 }, + ONLP_LED_STATUS_PRESENT, + ONLP_LED_CAPS_ON_OFF | ONLP_LED_CAPS_GREEN | ONLP_LED_CAPS_RED | ONLP_LED_CAPS_ORANGE, + }, + { + { ONLP_LED_ID_CREATE(LED_LOC), "LED 2 (LOC LED)", 0 }, + ONLP_LED_STATUS_PRESENT, + ONLP_LED_CAPS_ON_OFF | ONLP_LED_CAPS_ORANGE, + }, + { + { ONLP_LED_ID_CREATE(LED_FAN), "LED 3 (FAN LED)", 0 }, + ONLP_LED_STATUS_PRESENT, + ONLP_LED_CAPS_AUTO, + }, + { + { ONLP_LED_ID_CREATE(LED_PSU1), "LED 4 (PSU1 LED)", 0 }, + ONLP_LED_STATUS_PRESENT, + ONLP_LED_CAPS_AUTO, + }, + { + { ONLP_LED_ID_CREATE(LED_PSU2), "LED 4 (PSU2 LED)", 0 }, + ONLP_LED_STATUS_PRESENT, + ONLP_LED_CAPS_AUTO, + }, +}; + +static int driver_to_onlp_led_mode(enum onlp_led_id id, enum led_light_mode driver_led_mode) +{ + int i, nsize = sizeof(led_map)/sizeof(led_map[0]); + + for (i = 0; i < nsize; i++) + { + if (id == led_map[i].id && driver_led_mode == led_map[i].driver_led_mode) + { + return led_map[i].onlp_led_mode; + } + } + + return 0; +} + +static int onlp_to_driver_led_mode(enum onlp_led_id id, onlp_led_mode_t onlp_led_mode) +{ + int i, nsize = sizeof(led_map)/sizeof(led_map[0]); + + for(i = 0; i < nsize; i++) + { + if (id == led_map[i].id && onlp_led_mode == led_map[i].onlp_led_mode) + { + return led_map[i].driver_led_mode; + } + } + + return 0; +} + +/* + * This function will be called prior to any other onlp_ledi_* functions. + */ +int +onlp_ledi_init(void) +{ + onlp_ledi_mode_set(ONLP_LED_ID_CREATE(LED_DIAG), ONLP_LED_MODE_OFF); + onlp_ledi_mode_set(ONLP_LED_ID_CREATE(LED_LOC), ONLP_LED_MODE_OFF); + + return ONLP_STATUS_OK; +} + +int +onlp_ledi_info_get(onlp_oid_t id, onlp_led_info_t* info) +{ + int local_id; + char data[2] = {0}; + char fullpath[50] = {0}; + + VALIDATE(id); + + local_id = ONLP_OID_ID_GET(id); + + /* get fullpath */ + sprintf(fullpath, "%s%s/%s", prefix_path, last_path[local_id], filename); + + /* Set the onlp_oid_hdr_t and capabilities */ + *info = linfo[ONLP_OID_ID_GET(id)]; + + /* Set LED mode */ + if (onlp_file_read_string(fullpath, data, sizeof(data), 0) != 0) { + DEBUG_PRINT("%s(%d)\r\n", __FUNCTION__, __LINE__); + return ONLP_STATUS_E_INTERNAL; + } + + info->mode = driver_to_onlp_led_mode(local_id, atoi(data)); + + /* Set the on/off status */ + if (info->mode != ONLP_LED_MODE_OFF) { + info->status |= ONLP_LED_STATUS_ON; + } + + return ONLP_STATUS_OK; +} + +/* + * Turn an LED on or off. + * + * This function will only be called if the LED OID supports the ONOFF + * capability. + * + * What 'on' means in terms of colors or modes for multimode LEDs is + * up to the platform to decide. This is intended as baseline toggle mechanism. + */ +int +onlp_ledi_set(onlp_oid_t id, int on_or_off) +{ + VALIDATE(id); + + if (!on_or_off) { + return onlp_ledi_mode_set(id, ONLP_LED_MODE_OFF); + } + + return ONLP_STATUS_E_UNSUPPORTED; +} + +/* + * This function puts the LED into the given mode. It is a more functional + * interface for multimode LEDs. + * + * Only modes reported in the LED's capabilities will be attempted. + */ +int +onlp_ledi_mode_set(onlp_oid_t id, onlp_led_mode_t mode) +{ + int local_id; + char fullpath[50] = {0}; + + VALIDATE(id); + + local_id = ONLP_OID_ID_GET(id); + sprintf(fullpath, "%s%s/%s", prefix_path, last_path[local_id], filename); + + if (onlp_file_write_integer(fullpath, onlp_to_driver_led_mode(local_id, mode)) != 0) + { + return ONLP_STATUS_E_INTERNAL; + } + + return ONLP_STATUS_OK; +} + +/* + * Generic LED ioctl interface. + */ +int +onlp_ledi_ioctl(onlp_oid_t id, va_list vargs) +{ + return ONLP_STATUS_E_UNSUPPORTED; +} + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/make.mk b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/make.mk new file mode 100755 index 00000000..55af3d15 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/make.mk @@ -0,0 +1,9 @@ +############################################################################### +# +# +# +############################################################################### + +LIBRARY := x86_64_accton_csp9250 +$(LIBRARY)_SUBDIR := $(dir $(lastword $(MAKEFILE_LIST))) +include $(BUILDER)/lib.mk diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/platform_lib.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/platform_lib.c new file mode 100755 index 00000000..8d46f100 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/platform_lib.c @@ -0,0 +1,176 @@ +#include +#include +#include "platform_lib.h" +#include +#include "x86_64_accton_csp9250_log.h" + + +static int _onlp_file_write(char *filename, char *buffer, int buf_size, int data_len) +{ + int fd; + int len; + + if ((buffer == NULL) || (buf_size < 0)) { + return -1; + } + + if ((fd = open(filename, O_WRONLY, S_IWUSR)) == -1) { + return -1; + } + + if ((len = write(fd, buffer, buf_size)) < 0) { + close(fd); + return -1; + } + + if ((close(fd) == -1)) { + return -1; + } + + if ((len > buf_size) || (data_len != 0 && len != data_len)) { + return -1; + } + + return 0; +} + +int onlp_file_write_integer(char *filename, int value) +{ + char buf[8] = {0}; + sprintf(buf, "%d", value); + + return _onlp_file_write(filename, buf, (int)strlen(buf), 0); +} + +int onlp_file_read_binary(char *filename, char *buffer, int buf_size, int data_len) +{ + int fd; + int len; + + if ((buffer == NULL) || (buf_size < 0)) { + return -1; + } + + if ((fd = open(filename, O_RDONLY)) == -1) { + return -1; + } + + if ((len = read(fd, buffer, buf_size)) < 0) { + close(fd); + return -1; + } + + if ((close(fd) == -1)) { + return -1; + } + + if ((len > buf_size) || (data_len != 0 && len != data_len)) { + return -1; + } + + return 0; +} + +int onlp_file_read_string(char *filename, char *buffer, int buf_size, int data_len) +{ + int ret; + + if (data_len >= buf_size) { + return -1; + } + + ret = onlp_file_read_binary(filename, buffer, buf_size-1, data_len); + + if (ret == 0) { + buffer[buf_size-1] = '\0'; + } + + return ret; +} + +#define I2C_PSU_MODEL_NAME_LEN 9 +#define I2C_PSU_FAN_DIR_LEN 3 + +psu_type_t get_psu_type(int id, char* modelname, int modelname_len) +{ + char *node = NULL; + char model_name[I2C_PSU_MODEL_NAME_LEN + 1] = {0}; + char fan_dir[I2C_PSU_FAN_DIR_LEN + 1] = {0}; + + + /* Check AC model name */ + node = (id == PSU1_ID) ? PSU1_AC_HWMON_NODE(psu_model_name) : PSU2_AC_HWMON_NODE(psu_model_name); + + if (onlp_file_read_string(node, model_name, sizeof(model_name), 0) != 0) { + return PSU_TYPE_UNKNOWN; + } + + if (strncmp(model_name, "YM-2651Y", strlen("YM-2651Y")) != 0) { + return PSU_TYPE_UNKNOWN; + } + + if (modelname) { + strncpy(modelname, model_name, modelname_len-1); + } + + node = (id == PSU1_ID) ? PSU1_AC_PMBUS_NODE(psu_fan_dir) : PSU2_AC_PMBUS_NODE(psu_fan_dir); + + if (onlp_file_read_string(node, fan_dir, sizeof(fan_dir), 0) != 0) { + return PSU_TYPE_UNKNOWN; + } + + if (strncmp(fan_dir, "F2B", strlen("F2B")) == 0) { + return PSU_TYPE_AC_F2B; + } + + if (strncmp(fan_dir, "B2F", strlen("B2F")) == 0) { + return PSU_TYPE_AC_B2F; + } + + return PSU_TYPE_UNKNOWN; +} + +int psu_ym2651y_pmbus_info_get(int id, char *node, int *value) +{ + int ret = 0; + char path[PSU_NODE_MAX_PATH_LEN] = {0}; + + *value = 0; + + if (PSU1_ID == id) { + sprintf(path, "%s%s", PSU1_AC_PMBUS_PREFIX, node); + } + else { + sprintf(path, "%s%s", PSU2_AC_PMBUS_PREFIX, node); + } + + if (onlp_file_read_int(value, path) < 0) { + AIM_LOG_ERROR("Unable to read status from file(%s)\r\n", path); + return ONLP_STATUS_E_INTERNAL; + } + + return ret; +} + +int psu_ym2651y_pmbus_info_set(int id, char *node, int value) +{ + char path[PSU_NODE_MAX_PATH_LEN] = {0}; + + switch (id) { + case PSU1_ID: + sprintf(path, "%s%s", PSU1_AC_PMBUS_PREFIX, node); + break; + case PSU2_ID: + sprintf(path, "%s%s", PSU2_AC_PMBUS_PREFIX, node); + break; + default: + return ONLP_STATUS_E_UNSUPPORTED; + }; + + if (onlp_file_write_integer(path, value) < 0) { + AIM_LOG_ERROR("Unable to write data to file (%s)\r\n", path); + return ONLP_STATUS_E_INTERNAL; + } + + return ONLP_STATUS_OK; +} diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/platform_lib.h b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/platform_lib.h new file mode 100755 index 00000000..a4be5348 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/platform_lib.h @@ -0,0 +1,85 @@ +/************************************************************ + * + * + * Copyright 2014 Big Switch Networks, Inc. + * Copyright 2014 Accton Technology Corporation. + * + * Licensed under the Eclipse Public License, Version 1.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.eclipse.org/legal/epl-v10.html + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the + * License. + * + * + ************************************************************ + * + * + * + ***********************************************************/ +#ifndef __PLATFORM_LIB_H__ +#define __PLATFORM_LIB_H__ + +#include +#include "x86_64_accton_csp9250_log.h" + +#define CHASSIS_FAN_COUNT 5 +#define CHASSIS_THERMAL_COUNT 9 +#define CHASSIS_PSU_COUNT 2 +#define CHASSIS_LED_COUNT 5 + +#define PSU1_ID 1 +#define PSU2_ID 2 + +#define PSU_NODE_MAX_INT_LEN 8 +#define PSU_NODE_MAX_PATH_LEN 64 + +#define PSU1_AC_PMBUS_PREFIX "/sys/bus/i2c/devices/11-0059/" +#define PSU2_AC_PMBUS_PREFIX "/sys/bus/i2c/devices/10-0058/" + +#define PSU1_AC_PMBUS_NODE(node) PSU1_AC_PMBUS_PREFIX#node +#define PSU2_AC_PMBUS_NODE(node) PSU2_AC_PMBUS_PREFIX#node + +#define PSU1_AC_HWMON_PREFIX "/sys/bus/i2c/devices/11-0051/" +#define PSU2_AC_HWMON_PREFIX "/sys/bus/i2c/devices/10-0050/" + +#define PSU1_AC_HWMON_NODE(node) PSU1_AC_HWMON_PREFIX#node +#define PSU2_AC_HWMON_NODE(node) PSU2_AC_HWMON_PREFIX#node + +#define FAN_BOARD_PATH "/sys/bus/i2c/devices/2-0066/" +#define FAN_NODE(node) FAN_BOARD_PATH#node + +#define IDPROM_PATH "/sys/class/i2c-adapter/i2c-1/1-0057/eeprom" + +int onlp_file_write_integer(char *filename, int value); +int onlp_file_read_binary(char *filename, char *buffer, int buf_size, int data_len); +int onlp_file_read_string(char *filename, char *buffer, int buf_size, int data_len); + + +int psu_ym2651y_pmbus_info_get(int id, char *node, int *value); +int psu_ym2651y_pmbus_info_set(int id, char *node, int value); + +typedef enum psu_type { + PSU_TYPE_UNKNOWN, + PSU_TYPE_AC_F2B, + PSU_TYPE_AC_B2F +} psu_type_t; + +psu_type_t get_psu_type(int id, char* modelname, int modelname_len); + +//#define DEBUG_MODE 1 + +#if (DEBUG_MODE == 1) + #define DEBUG_PRINT(format, ...) printf(format, __VA_ARGS__) +#else + #define DEBUG_PRINT(format, ...) +#endif + +#endif /* __PLATFORM_LIB_H__ */ + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/psui.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/psui.c new file mode 100755 index 00000000..c6ece5c8 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/psui.c @@ -0,0 +1,239 @@ +/************************************************************ + * + * + * Copyright 2014 Big Switch Networks, Inc. + * Copyright 2014 Accton Technology Corporation. + * + * Licensed under the Eclipse Public License, Version 1.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.eclipse.org/legal/epl-v10.html + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the + * License. + * + * + ************************************************************ + * + * + * + ***********************************************************/ +#include +#include +//#include +#include +#include "platform_lib.h" + +#define PSU_STATUS_PRESENT 1 +#define PSU_STATUS_POWER_GOOD 1 +#define PSU_MAX_LENGTH 256 + +#define PSU_IPMI_TMP_FILE_RM "rm -f /tmp/psu_bmc_info > /dev/null 2>&1" +#define PSU_IPMI_TMP_FILE_ONE_ENTRY_RM "rm -f /tmp/psu_bmc_info_one_entry > /dev/null 2>&1" +#define PSU_IPMI_TMP_FILE "/tmp/psu_bmc_info" +#define PSU_IPMI_TMP_FILE_ONE_ENTRY "/tmp/psu_bmc_info_one_entry" +#define PSU_IPMI_TMP_FILE_FIND_NO_READ "No Reading" +#define PSU_IPMI_SDR_CMD_PSU "ipmitool sdr type 0x08" + + +#define VALIDATE(_id) \ + do { \ + if(!ONLP_OID_IS_PSU(_id)) { \ + return ONLP_STATUS_E_INVALID; \ + } \ + } while(0) + + +typedef enum onlp_psu_info_id_s +{ + PSU_INFO_VIN=0, + PSU_INFO_VOUT, + PSU_INFO_IIN, + PSU_INFO_IOUT, + PSU_INFO_PIN, + PSU_INFO_POUT, + PSU_INFO_TEMP, + PSU_INFO_MAX, +}onlp_psu_info_id_t; + +typedef struct onlp_psu_dev_info_s +{ + onlp_psu_info_id_t info_id; + char *tag; + char *find; +}onlp_psu_dev_info_t; + + +typedef struct onlp_psu_dev_s +{ + onlp_psu_dev_info_t psu_dev_info_table[PSU_INFO_MAX]; +}onlp_psu_dev_t; + + +onlp_psu_dev_t psu_sensor_table[]= +{ + { + { + {PSU_INFO_VIN, "PSU1_VIN", "Volts"}, + {PSU_INFO_VOUT, "PSU1_VOUT", "Volts"}, + {PSU_INFO_IIN, "PSU1_IIN", "Amps"}, + {PSU_INFO_IOUT, "PSU1_IOUT", "Amps"}, + {PSU_INFO_PIN, "PSU1_PIN", "Watts"}, + {PSU_INFO_POUT, "PSU1_POUT", "Watts"}, + {PSU_INFO_TEMP, "PSU1_TEMP", "degrees"} + }, + //"ipmitool sdr type 0x08", + }, + { + { + {PSU_INFO_VIN, "PSU2_VIN", "Volts"}, + {PSU_INFO_VOUT, "PSU2_VOUT", "Volts"}, + {PSU_INFO_IIN, "PSU2_IIN", "Amps"}, + {PSU_INFO_IOUT, "PSU2_IOUT", "Amps"}, + {PSU_INFO_PIN, "PSU2_PIN", "Watts"}, + {PSU_INFO_POUT, "PSU2_POUT", "Watts"}, + {PSU_INFO_TEMP, "PSU2_TEMP", "degrees"}, + }, + //"ipmitool sdr type 0x08", + } +}; + + + + + +//ipmitool sdr type 0x08s + +int +onlp_psui_init(void) +{ + return ONLP_STATUS_OK; +} + +/* + * Get all information about the given PSU oid. + */ +static onlp_psu_info_t pinfo[] = +{ + { }, /* Not used */ + { + { ONLP_PSU_ID_CREATE(PSU1_ID), "PSU-1", 0 }, + }, + { + { ONLP_PSU_ID_CREATE(PSU2_ID), "PSU-2", 0 }, + } +}; + +int +onlp_psui_info_get(onlp_oid_t id, onlp_psu_info_t* info) +{ +// int val = 0; + int ret = ONLP_STATUS_OK; + int index = ONLP_OID_ID_GET(id); + //psu_type_t psu_type; + int size=0; + onlp_psu_info_id_t i; + char cmd[PSU_MAX_LENGTH/2]={0}; + char psu_val_str[4]; + int psu_val_int=0; + uint8_t data[PSU_MAX_LENGTH] = {0}; + char /* *ipmi_cmd,*/ * tag, *find, *p; + + VALIDATE(id); + + memset(info, 0, sizeof(onlp_psu_info_t)); + *info = pinfo[index]; /* Set the onlp_oid_hdr_t */ + snprintf(cmd , (PSU_MAX_LENGTH/2)-1, "%s > %s", PSU_IPMI_SDR_CMD_PSU, PSU_IPMI_TMP_FILE); + system(cmd); + for(i=PSU_INFO_VIN;i %s", PSU_IPMI_TMP_FILE, tag, PSU_IPMI_TMP_FILE_ONE_ENTRY); + system(cmd); + if(onlp_file_read(data, PSU_MAX_LENGTH, &size, PSU_IPMI_TMP_FILE_ONE_ENTRY)!=ONLP_STATUS_OK) + { + return ONLP_STATUS_E_INTERNAL; + } + p=strstr((char*)data, find); + if(p==NULL) + { + p=strstr((char*)data, PSU_IPMI_TMP_FILE_FIND_NO_READ); + if(p==NULL) + return ONLP_STATUS_E_INTERNAL; + else + continue; + } + if(((uint8_t*)p-data) < sizeof(psu_val_str)/sizeof(char)) + { + return ONLP_STATUS_E_INTERNAL; + } + psu_val_str[0]=(data[(uint8_t*)p-data-4]=='|' || data[(uint8_t*)p-data-4]==' ')?'0':data[(uint8_t*)p-data-4]; + psu_val_str[1]=(data[(uint8_t*)p-data-3]=='|' || data[(uint8_t*)p-data-3]==' ')?'0':data[(uint8_t*)p-data-3]; + psu_val_str[2]=(data[(uint8_t*)p-data-2]=='|' || data[(uint8_t*)p-data-2]==' ')?'0':data[(uint8_t*)p-data-2]; + + psu_val_int=ONLPLIB_ATOI(psu_val_str); + if(!strcmp(tag, "PSU1_VIN") || !strcmp(tag, "PSU2_VIN")) + { + info->mvin= psu_val_int*100; + info->caps |= ONLP_PSU_CAPS_VIN; + } + if(!strcmp(tag, "PSU1_VOUT") || !strcmp(tag, "PSU2_VOUT")) + { + info->mvout= psu_val_int*100; + info->caps |= ONLP_PSU_CAPS_VOUT; + } + if(!strcmp(tag, "PSU1_IIN") || !strcmp(tag, "PSU2_IIN")) + { + info->miin= psu_val_int*100; + info->caps |= ONLP_PSU_CAPS_IIN; + } + if(!strcmp(tag, "PSU1_IOUT") || !strcmp(tag, "PSU2_IOUT")) + { + info->miout= psu_val_int*100; + info->caps |= ONLP_PSU_CAPS_IOUT; + } + if(!strcmp(tag, "PSU1_PIN") || !strcmp(tag, "PSU2_PIN")) + { + info->mpin= psu_val_int*100; + info->caps |= ONLP_PSU_CAPS_PIN; + } + if(!strcmp(tag, "PSU1_POUT") || !strcmp(tag, "PSU2_POUT")) + { + info->mpout= psu_val_int*100; + info->caps |= ONLP_PSU_CAPS_POUT; + } + + } + system(PSU_IPMI_TMP_FILE_RM); + if(info->mvin==0 && info->mvout ==0 && info->miin==0) + info->status &= ~ONLP_PSU_STATUS_PRESENT; + else + info->status |= ONLP_PSU_STATUS_PRESENT; + + if(info->mpout == 0) + info->status |= ONLP_PSU_STATUS_FAILED; + + /* Set the associated oid_table */ + info->hdr.coids[0] = ONLP_FAN_ID_CREATE(index + CHASSIS_FAN_COUNT); + info->hdr.coids[1] = ONLP_THERMAL_ID_CREATE(index + CHASSIS_THERMAL_COUNT); + + ret = ONLP_STATUS_OK; + + return ret; +} + +int +onlp_psui_ioctl(onlp_oid_t pid, va_list vargs) +{ + return ONLP_STATUS_E_UNSUPPORTED; +} + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/sfpi.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/sfpi.c new file mode 100755 index 00000000..9380d97f --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/sfpi.c @@ -0,0 +1,353 @@ +/************************************************************ + * + * + * Copyright 2014 Big Switch Networks, Inc. + * Copyright 2016 Accton Technology Corporation. + * + * Licensed under the Eclipse Public License, Version 1.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.eclipse.org/legal/epl-v10.html + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the + * License. + * + * + ************************************************************ + * + * + * + ***********************************************************/ +#include +#include +#include +#include "platform_lib.h" + +#include "x86_64_accton_csp9250_log.h" + +#define NUM_OF_SFP_PORT 54 +#define MAX_SFP_PATH 64 +#define QSFP_START_PORT 48 +static char sfp_node_path[MAX_SFP_PATH] = {0}; +#define FRONT_PORT_BUS_INDEX(port) (port+17) +#define FRONT_QSFP_PORT_BUS_INDEX(port) (port-39) + +static char* +sfp_get_port_path_addr(int port, int addr, char *node_name) +{ + if(port < QSFP_START_PORT) + sprintf(sfp_node_path, "/sys/bus/i2c/devices/%d-00%d/%s", + FRONT_PORT_BUS_INDEX(port), addr, node_name); + else + sprintf(sfp_node_path, "/sys/bus/i2c/devices/%d-00%d/%s", + FRONT_QSFP_PORT_BUS_INDEX(port), addr, node_name); + return sfp_node_path; +} + +static char* +sfp_get_port_path(int port, char *node_name) +{ + return sfp_get_port_path_addr(port, 50, node_name); +} + +/************************************************************ + * + * SFPI Entry Points + * + ***********************************************************/ +int +onlp_sfpi_init(void) +{ + /* Called at initialization time */ + return ONLP_STATUS_OK; +} + +int +onlp_sfpi_bitmap_get(onlp_sfp_bitmap_t* bmap) +{ + /* + * Ports {0, 54} + */ + int p; + AIM_BITMAP_CLR_ALL(bmap); + for(p = 0; p < NUM_OF_SFP_PORT; p++) { + AIM_BITMAP_SET(bmap, p); + } + + return ONLP_STATUS_OK; +} + +int +onlp_sfpi_is_present(int port) +{ + /* + * Return 1 if present. + * Return 0 if not present. + * Return < 0 if error. + */ + int present; + char *path = sfp_get_port_path(port, "sfp_is_present"); + + if (onlp_file_read_int(&present, path) < 0) { + AIM_LOG_ERROR("Unable to read present status from port(%d)\r\n", port); + return ONLP_STATUS_E_INTERNAL; + } + + return present; +} + +int +onlp_sfpi_presence_bitmap_get(onlp_sfp_bitmap_t* dst) +{ + uint32_t bytes[7]; + char* path; + FILE* fp; + + AIM_BITMAP_CLR_ALL(dst); + + path = sfp_get_port_path(0, "sfp_is_present_all"); + fp = fopen(path, "r"); + if(fp == NULL) { + AIM_LOG_ERROR("Unable to open the sfp_is_present_all device file."); + return ONLP_STATUS_E_INTERNAL; + } + int count = fscanf(fp, "%x %x %x %x %x %x %x", + bytes+0, + bytes+1, + bytes+2, + bytes+3, + bytes+4, + bytes+5, + bytes+6 + ); + fclose(fp); + if(count != AIM_ARRAYSIZE(bytes)) { + /* Likely a CPLD read timeout. */ + AIM_LOG_ERROR("Unable to read all fields from the sfp_is_present_all device file."); + return ONLP_STATUS_E_INTERNAL; + } + + /* Mask out non-existant QSFP ports */ + bytes[6] &= 0x3F; + + /* Convert to 64 bit integer in port order */ + int i = 0; + uint64_t presence_all = 0 ; + for(i = AIM_ARRAYSIZE(bytes)-1; i >= 0; i--) { + presence_all <<= 8; + presence_all |= bytes[i]; + } + + /* Populate bitmap */ + for(i = 0; presence_all; i++) { + AIM_BITMAP_MOD(dst, i, (presence_all & 1)); + presence_all >>= 1; + } + + return ONLP_STATUS_OK; +} + +int +onlp_sfpi_rx_los_bitmap_get(onlp_sfp_bitmap_t* dst) +{ + uint32_t bytes[6]; + char* path; + FILE* fp; + + path = sfp_get_port_path(0, "sfp_rx_los_all"); + fp = fopen(path, "r"); + + if(fp == NULL) { + AIM_LOG_ERROR("Unable to open the sfp_rx_los_all device file."); + return ONLP_STATUS_E_INTERNAL; + } + int count = fscanf(fp, "%x %x %x %x %x %x", + bytes+0, + bytes+1, + bytes+2, + bytes+3, + bytes+4, + bytes+5 + ); + fclose(fp); + if(count != 6) { + AIM_LOG_ERROR("Unable to read all fields from the sfp_rx_los_all device file."); + return ONLP_STATUS_E_INTERNAL; + } + + /* Convert to 64 bit integer in port order */ + int i = 0; + uint64_t rx_los_all = 0 ; + for(i = 5; i >= 0; i--) { + rx_los_all <<= 8; + rx_los_all |= bytes[i]; + } + + /* Populate bitmap */ + for(i = 0; rx_los_all; i++) { + AIM_BITMAP_MOD(dst, i, (rx_los_all & 1)); + rx_los_all >>= 1; + } + + return ONLP_STATUS_OK; +} + +int +onlp_sfpi_eeprom_read(int port, uint8_t data[256]) +{ + char* path = sfp_get_port_path(port, "sfp_eeprom"); + + /* + * Read the SFP eeprom into data[] + * + * Return MISSING if SFP is missing. + * Return OK if eeprom is read + */ + memset(data, 0, 256); + + if (onlp_file_read_binary(path, (char*)data, 256, 256) != 0) { + AIM_LOG_ERROR("Unable to read eeprom from port(%d)\r\n", port); + return ONLP_STATUS_E_INTERNAL; + } + + return ONLP_STATUS_OK; +} + +int +onlp_sfpi_dom_read(int port, uint8_t data[256]) +{ + char* path = sfp_get_port_path_addr(port, 51, "sfp_eeprom"); + memset(data, 0, 256); + + if (onlp_file_read_binary(path, (char*)data, 256, 256) != 0) { + AIM_LOG_INFO("Unable to read eeprom from port(%d)\r\n", port); + return ONLP_STATUS_E_INTERNAL; + } + + return ONLP_STATUS_OK; +} + +int +onlp_sfpi_control_set(int port, onlp_sfp_control_t control, int value) +{ + int rv; + + switch(control) + { + case ONLP_SFP_CONTROL_TX_DISABLE: + { + /* QSFP tx_disable that need to set eeprom. + * So if present=0. So not need to set + */ + if(port >=QSFP_START_PORT && port < NUM_OF_SFP_PORT) + { + rv = ONLP_STATUS_OK; + if(!onlp_sfpi_is_present(port)) + { + break; + } + break; + } + + char* path = sfp_get_port_path(port, "sfp_tx_disable"); + if (onlp_file_write_integer(path, value) != 0) { + AIM_LOG_ERROR("Unable to set tx_disable status to port(%d)\r\n", port); + rv = ONLP_STATUS_E_INTERNAL; + } + else { + rv = ONLP_STATUS_OK; + } + break; + } + + default: + rv = ONLP_STATUS_E_UNSUPPORTED; + break; + } + + return rv; +} + +int +onlp_sfpi_control_get(int port, onlp_sfp_control_t control, int* value) +{ + int rv; + char* path = NULL; + + switch(control) + { + case ONLP_SFP_CONTROL_RX_LOS: + { + path = sfp_get_port_path(port, "sfp_rx_los"); + + if (onlp_file_read_int(value, path) < 0) { + AIM_LOG_ERROR("Unable to read rx_los status from port(%d)\r\n", port); + rv = ONLP_STATUS_E_INTERNAL; + } + else { + rv = ONLP_STATUS_OK; + } + break; + } + + case ONLP_SFP_CONTROL_TX_FAULT: + { + path = sfp_get_port_path(port, "sfp_tx_fault"); + + if (onlp_file_read_int(value, path) < 0) { + AIM_LOG_ERROR("Unable to read tx_fault status from port(%d)\r\n", port); + rv = ONLP_STATUS_E_INTERNAL; + } + else { + rv = ONLP_STATUS_OK; + } + break; + } + + case ONLP_SFP_CONTROL_TX_DISABLE: + { + + /* QSFP tx_disable that need to set eeprom. + * So if present=0. So not need to set + */ + if(port >=QSFP_START_PORT && port <= NUM_OF_SFP_PORT) + { + if(!onlp_sfpi_is_present(port)) + { + rv = ONLP_STATUS_OK; + *value =0; + break; + } + } + path = sfp_get_port_path(port, "sfp_tx_disable"); + + if (onlp_file_read_int(value, path) < 0) { + AIM_LOG_ERROR("Unable to read tx_disabled status from port(%d)\r\n", port); + rv = ONLP_STATUS_E_INTERNAL; + } + else { + rv = ONLP_STATUS_OK; + } + break; + } + + default: + rv = ONLP_STATUS_E_UNSUPPORTED; + } + + return rv; +} + + +int +onlp_sfpi_denit(void) +{ + return ONLP_STATUS_OK; +} + + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/sysi.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/sysi.c new file mode 100755 index 00000000..8b4050dd --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/sysi.c @@ -0,0 +1,676 @@ +/************************************************************ + * + * + * Copyright 2014 Big Switch Networks, Inc. + * Copyright 2014 Accton Technology Corporation. + * + * Licensed under the Eclipse Public License, Version 1.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.eclipse.org/legal/epl-v10.html + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the + * License. + * + * + ************************************************************ + * + * + * + ***********************************************************/ +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include "platform_lib.h" +#include "x86_64_accton_csp9250_int.h" +#include "x86_64_accton_csp9250_log.h" + + +#define PREFIX_PATH_ON_CPLD_DEV "/sys/bus/i2c/devices/" +#define NUM_OF_CPLD 3 +#define FAN_DUTY_CYCLE_MAX (100) +#define FAN_DUTY_CYCLE_DEFAULT (32) +#define FAN_DUTY_PLUS_FOR_DIR (13) +/* Note, all chassis fans share 1 single duty setting. + * Here use fan 1 to represent global fan duty value.*/ +#define FAN_ID_FOR_SET_FAN_DUTY (1) +#define CELSIUS_RECORD_NUMBER (2) /*Must >= 2*/ + + +#define SYS_MAX_LENGTH 1024 +#define SYS_MAC_ADDR_LEN 6 +#define SYS_BUFFER_MAC_ADDR_LEN 17 +#define SYS_IPMI_FRU_CMD_0 "ipmitool fru print 0" +#define SYS_IPMI_FRU_CMD_1 "ipmitool fru print 1" +#define SYS_IPMI_TMP_FILE_0_RM "rm -f /tmp/sys_bmc_info_0 > /dev/null 2>&1" +#define SYS_IPMI_TMP_FILE_1_RM "rm -f /tmp/sys_bmc_info_0 > /dev/null 2>&1" +#define SYS_IPMI_TMP_FILE_0 "/tmp/sys_bmc_info_0" +#define SYS_IPMI_TMP_FILE_1 "/tmp/sys_bmc_info_1" +#define SYS_NETWORK_MAC_GET "cat /sys/class/net/ma1/address" +#define SYS_IPMI_TMP_FILE_MAC "/tmp/sys_network_mac" +#define SYS_IPMI_TMP_FILE_MAC_RM "rm -f /tmp/sys_network_mac > /dev/null 2>&1" + +typedef struct fan_ctrl_policy { + int duty_cycle; /* In percetage */ + int step_up_thermal; /* In mini-Celsius */ + int step_dn_thermal; /* In mini-Celsius */ +} fan_ctrl_policy_t; + +static char arr_cplddev_name[NUM_OF_CPLD][10] = +{ + "1-0060", + "2-0062", + "3-0064" +}; + +/* + * Tlvinf header: Layout of the header for the TlvInfo format + * + * See the end of this file for details of this eeprom format + */ +struct __attribute__ ((__packed__)) tlvinfo_header_s { + char signature[8]; /* 0x00 - 0x07 EEPROM Tag "TlvInfo" */ + u_int8_t version; /* 0x08 Structure version */ + u_int16_t totallen; /* 0x09 - 0x0A Length of all data which follows */ +}; +typedef struct tlvinfo_header_s tlvinfo_header_t; + +// Header Field Constants +#define SYS_EEPROM_SIZE 256 +#define TLV_INFO_ID_STRING "TlvInfo" +#define TLV_INFO_VERSION 0x01 +#define TLV_TOTAL_LEN_MAX (SYS_EEPROM_SIZE - sizeof(tlvinfo_header_t)) + +struct __attribute__ ((__packed__)) tlvinfo_tlv_s { + u_int8_t type; + u_int8_t length; + u_int8_t value[0]; +}; +typedef struct tlvinfo_tlv_s tlvinfo_tlv_t; + +/* Maximum length of a TLV value in bytes */ +#define TLV_VALUE_MAX_LEN 255 + +/** + * The TLV Types. + * + * Keep these in sync with tlv_code_list in cmd_sys_eeprom.c + */ +#define TLV_CODE_PRODUCT_NAME 0x21 +#define TLV_CODE_PART_NUMBER 0x22 +#define TLV_CODE_SERIAL_NUMBER 0x23 +#define TLV_CODE_MAC_BASE 0x24 +#define TLV_CODE_MANUF_DATE 0x25 +#define TLV_CODE_DEVICE_VERSION 0x26 +#define TLV_CODE_LABEL_REVISION 0x27 +#define TLV_CODE_PLATFORM_NAME 0x28 +#define TLV_CODE_ONIE_VERSION 0x29 +#define TLV_CODE_MAC_SIZE 0x2A +#define TLV_CODE_MANUF_NAME 0x2B +#define TLV_CODE_MANUF_COUNTRY 0x2C +#define TLV_CODE_VENDOR_NAME 0x2D +#define TLV_CODE_DIAG_VERSION 0x2E +#define TLV_CODE_SERVICE_TAG 0x2F +#define TLV_CODE_VENDOR_EXT 0xFD +#define TLV_CODE_CRC_32 0xFE + + + +typedef struct onlp_sys_eeprom_dev_s +{ + int tcode; + int size; + char *tag; + char *content; +}onlp_sys_eeprom_dev_t; + + +onlp_sys_eeprom_dev_t sys_eeprom_table[]= +{ + {TLV_CODE_PRODUCT_NAME, 0, "Board Part Number :", NULL}, + {TLV_CODE_PART_NUMBER, 0, "Chassis Part Number :", NULL}, + {TLV_CODE_SERIAL_NUMBER, 0, "Chassis Serial :", NULL}, + {TLV_CODE_MAC_BASE, SYS_MAC_ADDR_LEN, "MAC", "NULL"}, + {TLV_CODE_MANUF_DATE, 0, "Board Mfg Date :", NULL}, + {TLV_CODE_MAC_SIZE, 0, "MAC Range :", "55"}, + {TLV_CODE_LABEL_REVISION,0, "Product Version :", NULL}, + {TLV_CODE_PLATFORM_NAME, 0, "Product Part Number :", NULL}, + //{TLV_CODE_ONIE_VERSION, 4, "Fixed" ,"Onie"}, + {TLV_CODE_MANUF_NAME, 0, "Board Mfg :", NULL}, + //{TLV_CODE_MANUF_COUNTRY, 2, "Fixed", "TW"}, + //{TLV_CODE_VENDOR_NAME, 8, "Fixed", "Edgecore"}, + //{TLV_CODE_DIAG_VERSION, 4, "Fixed", "diag"} +}; + + +extern uint32_t +onlp_crc32(uint32_t crc, const void *buf, int size); + +const char* +onlp_sysi_platform_get(void) +{ + return "x86-64-accton-csp9250-r0"; +} + +char *ptr=NULL, *ptr_start=NULL, *ptr_end=NULL; + +int +onlp_sysi_onie_data_get(uint8_t** data, int* size) +{ + int byte=0,i=0; + int index=0, new_tlv_len=0; + uint8_t* eeprom = aim_zmalloc(SYS_EEPROM_SIZE); + char mac_addr[SYS_MAC_ADDR_LEN]={0}; + char cmd[SYS_MAX_LENGTH/4]={0}; + uint8_t read_buf[SYS_MAX_LENGTH] = {0}; + tlvinfo_header_t *eeprom_hdr = (tlvinfo_header_t *) eeprom; + tlvinfo_tlv_t *eeprom_tlv; + tlvinfo_tlv_t * eeprom_crc; + unsigned int calc_crc; + + + memset(eeprom, 0x0, SYS_EEPROM_SIZE); + strcpy(eeprom_hdr->signature, TLV_INFO_ID_STRING); + eeprom_hdr->version = TLV_INFO_VERSION; + eeprom_hdr->totallen =htons(0); + + system(SYS_IPMI_TMP_FILE_0_RM); + system(SYS_IPMI_TMP_FILE_MAC_RM); + snprintf(cmd , (SYS_MAX_LENGTH/4)-1, "%s > %s", SYS_NETWORK_MAC_GET, SYS_IPMI_TMP_FILE_MAC); + system(cmd); + if(onlp_file_read(read_buf, SYS_BUFFER_MAC_ADDR_LEN, &byte, SYS_IPMI_TMP_FILE_MAC)!=ONLP_STATUS_OK) + { + return ONLP_STATUS_E_INTERNAL; + } + sscanf((char*)read_buf, "%02x:%02x:%02x:%02x:%02x:%02x", (int*)&mac_addr[0], (int*)&mac_addr[1], (int*)&mac_addr[2], (int*)&mac_addr[3], (int*)&mac_addr[4], (int*)&mac_addr[5]); + + snprintf(cmd , (SYS_MAX_LENGTH/4)-1, "%s > %s", SYS_IPMI_FRU_CMD_0, SYS_IPMI_TMP_FILE_0); + system(cmd); + + if(onlp_file_read(read_buf, SYS_MAX_LENGTH, &byte, SYS_IPMI_TMP_FILE_0)!=ONLP_STATUS_OK) + { + return ONLP_STATUS_E_INTERNAL; + } + + index +=sizeof(tlvinfo_header_t); + + for(i=0; i < sizeof(sys_eeprom_table)/sizeof(onlp_sys_eeprom_dev_t); i++) + { + if(sys_eeprom_table[i].size!=0) + { + eeprom_tlv = (tlvinfo_tlv_t *) &eeprom[index]; + eeprom_tlv->type = sys_eeprom_table[i].tcode; + if(sys_eeprom_table[i].tcode==TLV_CODE_MAC_BASE) + { + eeprom_tlv->length = SYS_MAC_ADDR_LEN; + memcpy(eeprom_tlv->value, mac_addr, eeprom_tlv->length); + + } + else + { + eeprom_tlv->length = sys_eeprom_table[i].size; + memcpy(eeprom_tlv->value, sys_eeprom_table[i].content, eeprom_tlv->length); + } + index+=sizeof(tlvinfo_tlv_t); + index+=eeprom_tlv->length; + } + else + { + ptr=strstr((char*)read_buf, sys_eeprom_table[i].tag); + if(ptr!=NULL) + { + ptr_end = strchr(ptr, '\n'); + ptr_start = strchr(ptr, ':'); + if(ptr_start !=NULL && ptr_end!=NULL) + { + new_tlv_len=ptr_end-ptr_start-2; + eeprom_tlv = (tlvinfo_tlv_t *) &eeprom[index]; + eeprom_tlv->type = sys_eeprom_table[i].tcode; + eeprom_tlv->length = new_tlv_len; + memcpy(eeprom_tlv->value, ptr_start+2, new_tlv_len); + index+=sizeof(tlvinfo_tlv_t); + index+=new_tlv_len; + + } + } + } + + } + + eeprom_hdr->totallen = htons(index - sizeof(tlvinfo_header_t) +sizeof(tlvinfo_tlv_t)+4); + + eeprom_crc = (tlvinfo_tlv_t *) &eeprom[index]; + eeprom_crc->type = TLV_CODE_CRC_32; + eeprom_crc->length = 4; + + /* Calculate the checksum */ + calc_crc = onlp_crc32(0, (void *)eeprom, + sizeof(tlvinfo_header_t) + + htons(eeprom_hdr->totallen) - 4); + eeprom_crc->value[0] = (calc_crc >> 24) & 0xFF; + eeprom_crc->value[1] = (calc_crc >> 16) & 0xFF; + eeprom_crc->value[2] = (calc_crc >> 8) & 0xFF; + eeprom_crc->value[3] = (calc_crc >> 0) & 0xFF; + *size = SYS_EEPROM_SIZE; + *data = eeprom; + + return ONLP_STATUS_OK; +} + +int +onlp_sysi_oids_get(onlp_oid_t* table, int max) +{ + int i; + onlp_oid_t* e = table; + memset(table, 0, max*sizeof(onlp_oid_t)); + + /* 5 Thermal sensors on the chassis */ + for (i = 1; i <= CHASSIS_THERMAL_COUNT; i++) { + *e++ = ONLP_THERMAL_ID_CREATE(i); + } + + /* 5 LEDs on the chassis */ + for (i = 1; i <= CHASSIS_LED_COUNT; i++) { + *e++ = ONLP_LED_ID_CREATE(i); + } + + /* 2 PSUs on the chassis */ + for (i = 1; i <= CHASSIS_PSU_COUNT; i++) { + *e++ = ONLP_PSU_ID_CREATE(i); + } + + /* 6 Fans on the chassis */ + for (i = 1; i <= CHASSIS_FAN_COUNT; i++) { + *e++ = ONLP_FAN_ID_CREATE(i); + } + + return 0; +} + +int +onlp_sysi_platform_info_get(onlp_platform_info_t* pi) +{ + int i, v[NUM_OF_CPLD]={0}; + + for (i = 0; i < NUM_OF_CPLD; i++) { + v[i] = 0; + + if(onlp_file_read_int(v+i, "%s%s/version", PREFIX_PATH_ON_CPLD_DEV, arr_cplddev_name[i]) < 0) { + return ONLP_STATUS_E_INTERNAL; + } + } + pi->cpld_versions = aim_fstrdup("%d.%d.%d", v[0], v[1], v[2]); + + return 0; +} + +void +onlp_sysi_platform_info_free(onlp_platform_info_t* pi) +{ + aim_free(pi->cpld_versions); +} + +/* Thermal plan: + * $TMP = (CPU_core + LM75_1+ LM75_2 + LM75_3 + LM75_4)/5 + * 1. If any FAN failed, set all the other fans as full speed, 100%. + * 2. If any sensor is high than 45 degrees, set fan speed to duty 62.5%. + * 3. If any sensor is high than 50 degrees, set fan speed to duty 100%. + * 4. When $TMP >= 40 C, set fan speed to duty 62.5%. + * 5. When $TMP >= 45 C, set fan speed to duty 100%. + * 6. When $TMP < 35 C, set fan speed to duty 31.25%. + * 7. Direction factor, when B2F, duty + 12.5%. + * + * Note, all chassis fans share 1 single duty setting. + */ +fan_ctrl_policy_t fan_ctrl_policy_avg[] = { +{FAN_DUTY_CYCLE_MAX , 45000, INT_MIN}, +{63 , 40000, INT_MIN}, +{32 , INT_MAX, 35000}, +}; + +fan_ctrl_policy_t fan_ctrl_policy_single[] = { +{FAN_DUTY_CYCLE_MAX , 50000, INT_MIN}, +{63 , 45000, INT_MIN}, +}; + +struct fan_control_data_s { + int duty_cycle; + int dir_plus; + int mc_avg_pre[CELSIUS_RECORD_NUMBER]; + int mc_high_pre[CELSIUS_RECORD_NUMBER]; + +} fan_control_data_pre = +{ + .duty_cycle = FAN_DUTY_CYCLE_DEFAULT, + .dir_plus = 0, + .mc_avg_pre = {INT_MIN+1, INT_MIN}, /*init as thermal rising to avoid full speed.*/ + .mc_high_pre = {INT_MIN+1, INT_MIN}, /*init as thermal rising to avoid full speed.*/ + +}; + +static int +sysi_check_fan(uint32_t *fan_dir){ + int i, present; + + for (i = 1; i <= CHASSIS_FAN_COUNT; i++) + { + onlp_fan_info_t fan_info; + + if (onlp_fani_info_get(ONLP_FAN_ID_CREATE(i), &fan_info) != ONLP_STATUS_OK) { + AIM_LOG_ERROR("Unable to get fan(%d) status\r\n", i); + return ONLP_STATUS_E_INTERNAL; + } + + present = fan_info.status & ONLP_FAN_STATUS_PRESENT; + if ((fan_info.status & ONLP_FAN_STATUS_FAILED) || !present) { + AIM_LOG_WARN("Fan(%d) is not working, set the other fans as full speed\r\n", i); + int ret = onlp_fani_percentage_set( + ONLP_FAN_ID_CREATE(FAN_ID_FOR_SET_FAN_DUTY), FAN_DUTY_CYCLE_MAX); + if (ret != ONLP_STATUS_OK) + return ret; + else + return ONLP_STATUS_E_MISSING; + } + + /* Get fan direction (Only get the first one since all fan direction are the same) + */ + if (i == 1) { + *fan_dir = fan_info.status & (ONLP_FAN_STATUS_F2B|ONLP_FAN_STATUS_B2F); + } + } + + return ONLP_STATUS_OK; +} + +static int +sysi_get_fan_duty(int *cur_duty_cycle){ + int fd, len; + char buf[10] = {0}; + char *node = FAN_NODE(fan_duty_cycle_percentage); + + /* Get current fan duty*/ + fd = open(node, O_RDONLY); + if (fd == -1){ + AIM_LOG_ERROR("Unable to open fan speed control node (%s)", node); + return ONLP_STATUS_E_INTERNAL; + } + + len = read(fd, buf, sizeof(buf)); + close(fd); + if (len <= 0) { + AIM_LOG_ERROR("Unable to read fan speed from (%s)", node); + return ONLP_STATUS_E_INTERNAL; + } + *cur_duty_cycle = atoi(buf); + + return ONLP_STATUS_OK; +} + +static int +sysi_get_thermal_sum(int *mcelsius){ + onlp_thermal_info_t thermal_info; + int i; + + *mcelsius = 0; + for (i = 1; i <= CHASSIS_THERMAL_COUNT; i++) { + if (onlp_thermali_info_get(ONLP_THERMAL_ID_CREATE(i), &thermal_info) + != ONLP_STATUS_OK) { + AIM_LOG_ERROR("Unable to read thermal status"); + return ONLP_STATUS_E_INTERNAL; + } + *mcelsius += thermal_info.mcelsius; + + DEBUG_PRINT("Thermal %d: %d \n ", i, thermal_info.mcelsius); + + } + + return ONLP_STATUS_OK; + +} + +static int +sysi_get_highest_thermal(int *mcelsius){ + onlp_thermal_info_t thermal_info; + int i, highest; + + highest = 0; + for (i = 1; i <= CHASSIS_THERMAL_COUNT; i++) { + if (onlp_thermali_info_get(ONLP_THERMAL_ID_CREATE(i), &thermal_info) + != ONLP_STATUS_OK) { + AIM_LOG_ERROR("Unable to read thermal status"); + return ONLP_STATUS_E_INTERNAL; + } + highest = (thermal_info.mcelsius > highest)? + thermal_info.mcelsius : highest; + } + *mcelsius = highest; + return ONLP_STATUS_OK; +} + +/* Anaylze thermal changing history to judge if the change is a stable trend. */ +static int _is_thermal_a_trend(int *mc_history){ + int i, trend, trended; + + if (mc_history == NULL) { + AIM_LOG_ERROR("Unable to get history of thermal\n"); + return 0; + } + + /* Get heat up/down trend. */ + trend = 0; + for (i = 0; i < CELSIUS_RECORD_NUMBER; i++) { + if (( mc_history[i+1] < mc_history[i])){ + trend++; + }else if (( mc_history[i+1] > mc_history[i])){ + trend--; + } + } + + trended = (abs(trend) >= ((CELSIUS_RECORD_NUMBER+1)/2))? 1:0; +#if (DEBUG_MODE == 1) + DEBUG_PRINT("[INFO]%s#%d, trended: %d, UP/DW: %d mcelsius:", + __func__, __LINE__, trended, trend ); + for (i = 0; i <= CELSIUS_RECORD_NUMBER; i++) { + DEBUG_PRINT(" %d =>", mc_history[i]); + } + DEBUG_PRINT("%c\n", ' '); +#endif + + /*For more than half changes are same direction, it's a firm trend.*/ + return trended; +} + + +/* Decide duty by highest value of thermal sensors.*/ +static int +sysi_get_duty_by_highest(int *duty_cycle){ + int i, ret, maxtrix_len; + int new_duty_cycle = 0 ; + int mc_history[CELSIUS_RECORD_NUMBER+1] = {0}; + int *mcelsius_pre_p = &mc_history[1]; + int *mcelsius_now_p = &mc_history[0]; + + /* Fill up mcelsius array, + * [0] is current temperature, others are history. + */ + ret = sysi_get_highest_thermal(mcelsius_now_p); + if(ONLP_STATUS_OK != ret){ + return ret; + } + memcpy (mcelsius_pre_p, fan_control_data_pre.mc_high_pre, + sizeof(fan_control_data_pre.mc_high_pre)); + + DEBUG_PRINT("[INFO]%s#%d, highest mcelsius:%d!\n", + __func__, __LINE__, *mcelsius_now_p); + + /* Shift records to the right */ + for (i = 0; i < CELSIUS_RECORD_NUMBER; i++) { + fan_control_data_pre.mc_high_pre[i] = mc_history[i]; + } + + /* Only change duty on consecutive heat rising or falling.*/ + maxtrix_len = AIM_ARRAYSIZE(fan_ctrl_policy_single); + + /* Only change duty when the thermal changing are firm. */ + if (_is_thermal_a_trend(mc_history)) + { + int matched = 0; + for (i = 0; i < maxtrix_len; i++) { + if ((*mcelsius_now_p > fan_ctrl_policy_single[i].step_up_thermal)) { + new_duty_cycle = fan_ctrl_policy_single[i].duty_cycle; + matched = !matched; + break; + } + } +/* if (!matched) { + DEBUG_PRINT("%s#%d, celsius(%d) falls into undefined range!!\n", + __func__, __LINE__, *mcelsius_now_p); + } */ + } + *duty_cycle = new_duty_cycle; + return ONLP_STATUS_OK; +} + +/* Decide duty by average value of thermal sensors.*/ +static int +sysi_get_duty_by_average(int *duty_cycle){ + int i, mcelsius_avg, ret, maxtrix_len; + int new_duty_cycle=0; + int mc_history[CELSIUS_RECORD_NUMBER+1] = {0}; + int *mcelsius_pre_p = &mc_history[1]; + int *mcelsius_now_p = &mc_history[0]; + + /* Fill up mcelsius array, + * [0] is current temperature, others are history. + */ + *mcelsius_now_p = 0; + ret = sysi_get_thermal_sum(mcelsius_now_p); + if(ONLP_STATUS_OK != ret){ + return ret; + } + mcelsius_avg = (*mcelsius_now_p)/CHASSIS_THERMAL_COUNT; + + memcpy (mcelsius_pre_p, fan_control_data_pre.mc_avg_pre, + sizeof(fan_control_data_pre.mc_avg_pre)); + + DEBUG_PRINT("[INFO]%s#%d, mcelsius:%d!\n", __func__, __LINE__, mcelsius_avg); + + /* Shift records to the right */ + for (i = 0; i < CELSIUS_RECORD_NUMBER; i++) { + fan_control_data_pre.mc_avg_pre[i] = mc_history[i]; + } + + /* Only change duty on consecutive heat rising or falling.*/ + maxtrix_len = AIM_ARRAYSIZE(fan_ctrl_policy_avg); + + /* Only change duty when the thermal changing are firm. */ + if (_is_thermal_a_trend(mc_history)) + { + int matched = 0; + for (i = 0; i < maxtrix_len; i++) { + if ((mcelsius_avg >= fan_ctrl_policy_avg[i].step_up_thermal)) { + new_duty_cycle = fan_ctrl_policy_avg[i].duty_cycle; + matched = !matched; + break; + } + } + for (i = maxtrix_len-1; i>=0; i--) { + if ((mcelsius_avg < fan_ctrl_policy_avg[i].step_dn_thermal)) { + new_duty_cycle = fan_ctrl_policy_avg[i].duty_cycle; + matched = !matched; + break; + } + } + /*if (!matched) { + DEBUG_PRINT("%s#%d, celsius(%d) falls into undefined range!!\n", + __func__, __LINE__, mcelsius_avg); + } */ + } + + *duty_cycle = new_duty_cycle; + return ONLP_STATUS_OK; +} + +int +onlp_sysi_platform_manage_fans(void) +{ + uint32_t fan_dir; + int ret; + int cur_duty_cycle, new_duty_cycle, tmp; + int direct_addon = 0; + onlp_oid_t fan_duty_oid = ONLP_FAN_ID_CREATE(FAN_ID_FOR_SET_FAN_DUTY); + + /********************************************************** + * Decision 1: Set fan as full speed if any fan is failed. + **********************************************************/ + ret = sysi_check_fan(&fan_dir); + if(ONLP_STATUS_OK != ret){ + return ret; + } + + if (fan_dir & ONLP_FAN_STATUS_B2F) { + direct_addon = FAN_DUTY_PLUS_FOR_DIR; + } + + /********************************************************** + * Decision 2: If no matched fan speed is found from the policy, + * use FAN_DUTY_CYCLE_MIN as default speed + **********************************************************/ + ret = sysi_get_fan_duty(&cur_duty_cycle); + if(ONLP_STATUS_OK != ret){ + return ret; + } + + /********************************************************** + * Decision 3: Decide new fan speed depend on fan direction and temperature + **********************************************************/ + ret = sysi_get_duty_by_average(&new_duty_cycle); + if (ONLP_STATUS_OK != ret){ + return ret; + } + ret = sysi_get_duty_by_highest(&tmp); + if (ONLP_STATUS_OK != ret){ + return ret; + } + + new_duty_cycle = (tmp > new_duty_cycle)? tmp : new_duty_cycle; + if (new_duty_cycle == 0) + { + new_duty_cycle = fan_control_data_pre.duty_cycle; + } else { + fan_control_data_pre.duty_cycle = new_duty_cycle; + } + fan_control_data_pre.dir_plus = direct_addon; + DEBUG_PRINT("[INFO]%s#%d, new duty: %d = %d + %d (%d)!\n", __func__, __LINE__, + new_duty_cycle + direct_addon, new_duty_cycle, direct_addon, cur_duty_cycle); + + new_duty_cycle += direct_addon; + new_duty_cycle = (new_duty_cycle > FAN_DUTY_CYCLE_MAX)? + FAN_DUTY_CYCLE_MAX : new_duty_cycle; + + if (new_duty_cycle == cur_duty_cycle) { + /* Duty cycle does not change, just return */ + return ONLP_STATUS_OK; + } + + return onlp_fani_percentage_set(fan_duty_oid, new_duty_cycle); +} + +int +onlp_sysi_platform_manage_leds(void) +{ + return ONLP_STATUS_E_UNSUPPORTED; +} + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/thermali.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/thermali.c new file mode 100755 index 00000000..e0b0c75f --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/thermali.c @@ -0,0 +1,333 @@ +/************************************************************ + * + * + * Copyright 2014 Big Switch Networks, Inc. + * Copyright 2014 Accton Technology Corporation. + * + * Licensed under the Eclipse Public License, Version 1.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.eclipse.org/legal/epl-v10.html + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the + * License. + * + * + ************************************************************ + * + * Thermal Sensor Platform Implementation. + * + ***********************************************************/ +//#include +#include +#include +#include +#include +#include "platform_lib.h" + +//#define PSU_THERMAL_PATH_FORMAT "/sys/bus/i2c/devices/%s/*psu_temp1_input" +#define THERMAL_IPMI_TMP_FILE "/tmp/thermal_bmc_info" +#define THERMAL_IPMI_TMP_FILE_RM "rm -f /tmp/thermal_bmc_info > /dev/null 2>&1" +#define THERMAL_IPMI_TMP_FILE_FIND "degrees" +#define THERMAL_CHECK_TIME "/usr/bin/thermal_check_time" +#define THERMAL_IPMI_SDR_CMD "ipmitool sdr list" +#define THERMAL_IPMI_SDR_FILE "/usr/bin/thermal_bmc_sdr" +#define THERMAL_IPMI_SDR_FILE_RM "rm -f /usr/bin/thermal_bmc_sdr > /dev/null 2>&1" + +#define THERMAL_CAN_SET_IPMI_TIME 10 +#define THERMAL_MAX_LENGTH 256 +#define VALIDATE(_id) \ + do { \ + if(!ONLP_OID_IS_THERMAL(_id)) { \ + return ONLP_STATUS_E_INVALID; \ + } \ + } while(0) + +enum onlp_thermal_id +{ + THERMAL_RESERVED = 0, + THERMAL_CPU_CORE, + THERMAL_1_ON_SWITCH_BOARD, + THERMAL_2_ON_SWITCH_BOARD, + THERMAL_3_ON_SWITCH_BOARD, + THERMAL_1_ON_SERVER_BOARD, + THERMAL_2_ON_SERVER_BOARD, + THERMAL_3_ON_SERVER_BOARD, + THERMAL_1_ON_PSU1, + THERMAL_1_ON_PSU2, +}; + +typedef struct onlp_thermal_dev_s +{ + int thermal_id; + char *ipmi_cmd; + char *tag; + +}onlp_thermal_dev_t; + +onlp_thermal_dev_t thermal_sensor_table[]= +{ + {THERMAL_RESERVED, NULL, NULL}, + {THERMAL_CPU_CORE, NULL, NULL}, + {THERMAL_1_ON_SWITCH_BOARD, "ipmitool sdr list", "Temp_LM75_Power"}, + {THERMAL_2_ON_SWITCH_BOARD, "ipmitool sdr list", "Temp_LM75_LEFT"}, + {THERMAL_3_ON_SWITCH_BOARD, "ipmitool sdr list", "Temp_LM75_HS"}, + {THERMAL_1_ON_SERVER_BOARD, "ipmitool sdr list", "Temp_LM75_CPU0"}, + {THERMAL_2_ON_SERVER_BOARD, "ipmitool sdr list", "Temp_LM75_CPU1"}, + {THERMAL_3_ON_SERVER_BOARD, "ipmitool sdr list", "Temp_LM75_PCH"}, + {THERMAL_1_ON_PSU1, "ipmitool sdr list", "PSU1_TEMP"}, + {THERMAL_1_ON_PSU2, "ipmitool sdr list", "PSU2_TEMP"} +}; + +char *onlp_find_thermal_sensor_cmd(unsigned int id) +{ + int i; + for(i=0; i %s ", THERMAL_CHECK_TIME); + system(cmd); + system("echo V0002 > /etc/onlp_drv_version"); + return ONLP_STATUS_OK; +} + + +static int +thermali_time_exist(void) +{ + struct stat file_info; + if(stat(THERMAL_CHECK_TIME ,&file_info)==0) + { + if(file_info.st_size==0) + return 0; + return 1; + } + else + return 1; + +} +static int +thermali_sdr_file_exist(void) +{ + struct stat file_info; + if(stat(THERMAL_IPMI_SDR_FILE ,&file_info)==0) + { + if(file_info.st_size==0) + return 0; + return 1; + } + else + return 0; + +} + + +/* + * Retrieve the information structure for the given thermal OID. + * + * If the OID is invalid, return ONLP_E_STATUS_INVALID. + * If an unexpected error occurs, return ONLP_E_STATUS_INTERNAL. + * Otherwise, return ONLP_STATUS_OK with the OID's information. + * + * Note -- it is expected that you fill out the information + * structure even if the sensor described by the OID is not present. + */ +int +onlp_thermali_info_get(onlp_oid_t id, onlp_thermal_info_t* info) +{ + int tid; + int size; + char cmd[THERMAL_MAX_LENGTH/2] = {0}; + char temp[4]; + uint8_t data[THERMAL_MAX_LENGTH] = {0}; + //char *ipmi_cmd; + char * tag, *p; + struct timeval new_tv; + long last_time; + int get_data_by_ipmi=0; + + VALIDATE(id); + + tid = ONLP_OID_ID_GET(id); + + if(tid > THERMAL_1_ON_PSU2 || tid <= THERMAL_RESERVED) + return ONLP_STATUS_E_INTERNAL; + /* Set the onlp_oid_hdr_t and capabilities */ + *info = linfo[tid]; + + if(tid == THERMAL_CPU_CORE) { + return onlp_file_read_int_max(&info->mcelsius, cpu_coretemp_files); + } + if(thermali_time_exist()) + { + if(onlp_file_read(data, THERMAL_MAX_LENGTH, &size, THERMAL_CHECK_TIME)!=ONLP_STATUS_OK) + { + last_time=0; + } + else + last_time = atol((char*)data); + } + else + last_time=0; + + gettimeofday(&new_tv,NULL); + + if(last_time==0) /* first time */ + { + get_data_by_ipmi=1; + } + else + { + if(new_tv.tv_sec > last_time) + { + if((new_tv.tv_sec - last_time) > THERMAL_CAN_SET_IPMI_TIME) + { + get_data_by_ipmi=1; + } + else + get_data_by_ipmi=0; + } + else if(new_tv.tv_sec == last_time) + get_data_by_ipmi=0; + else + get_data_by_ipmi=1; + + } + memset(data ,0x0, THERMAL_MAX_LENGTH); + snprintf((char*)data, THERMAL_MAX_LENGTH-1, "%ld", new_tv.tv_sec); + if(onlp_file_write_str((char*)data, THERMAL_CHECK_TIME)!=ONLP_STATUS_OK) + { + return ONLP_STATUS_E_INTERNAL; + } + if(get_data_by_ipmi || !thermali_sdr_file_exist()) /* Set ipmitool cmd to get all data and save to file*/ + { + /* set ipmi cmd */ + snprintf(cmd, (THERMAL_MAX_LENGTH/2) -1, "%s > %s ", THERMAL_IPMI_SDR_CMD, THERMAL_IPMI_SDR_FILE); + system(cmd); + fflush(stdout); + } + tag= thermal_sensor_table[tid].tag; + + if(tag==NULL) + return ONLP_STATUS_E_INTERNAL; + + snprintf(cmd, (THERMAL_MAX_LENGTH/2) -1, "cat %s|grep %s > %s ", THERMAL_IPMI_SDR_FILE, tag, THERMAL_IPMI_TMP_FILE); + system(cmd); + + if(onlp_file_read(data, THERMAL_MAX_LENGTH, &size, THERMAL_IPMI_TMP_FILE)!=ONLP_STATUS_OK) + { + return ONLP_STATUS_E_INTERNAL; + } + p=strstr((char*)data, THERMAL_IPMI_TMP_FILE_FIND); + if(p==NULL) + { + return ONLP_STATUS_E_INTERNAL; + } + if(((uint8_t*)p-data) < sizeof(temp)/sizeof(char)) + { + return ONLP_STATUS_E_INTERNAL; + } + + temp[0]=data[(uint8_t*)p-data-4]; + temp[1]=data[(uint8_t*)p-data-3]; + temp[2]=data[(uint8_t*)p-data-2]; + info->mcelsius=ONLPLIB_ATOI(temp) * 1000; + + return ONLP_STATUS_OK; +} + + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_config.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_config.c new file mode 100755 index 00000000..9caedcad --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_config.c @@ -0,0 +1,81 @@ +/**************************************************************************//** + * + * + * + *****************************************************************************/ +#include + +/* */ +#define __x86_64_accton_csp9250_config_STRINGIFY_NAME(_x) #_x +#define __x86_64_accton_csp9250_config_STRINGIFY_VALUE(_x) __x86_64_accton_csp9250_config_STRINGIFY_NAME(_x) +x86_64_accton_csp9250_config_settings_t x86_64_accton_csp9250_config_settings[] = +{ +#ifdef x86_64_accton_csp9250_CONFIG_INCLUDE_LOGGING + { __x86_64_accton_csp9250_config_STRINGIFY_NAME(x86_64_accton_csp9250_CONFIG_INCLUDE_LOGGING), __x86_64_accton_csp9250_config_STRINGIFY_VALUE(x86_64_accton_csp9250_CONFIG_INCLUDE_LOGGING) }, +#else +{ x86_64_accton_csp9250_CONFIG_INCLUDE_LOGGING(__x86_64_accton_csp9250_config_STRINGIFY_NAME), "__undefined__" }, +#endif +#ifdef x86_64_accton_csp9250_CONFIG_LOG_OPTIONS_DEFAULT + { __x86_64_accton_csp9250_config_STRINGIFY_NAME(x86_64_accton_csp9250_CONFIG_LOG_OPTIONS_DEFAULT), __x86_64_accton_csp9250_config_STRINGIFY_VALUE(x86_64_accton_csp9250_CONFIG_LOG_OPTIONS_DEFAULT) }, +#else +{ x86_64_accton_csp9250_CONFIG_LOG_OPTIONS_DEFAULT(__x86_64_accton_csp9250_config_STRINGIFY_NAME), "__undefined__" }, +#endif +#ifdef x86_64_accton_csp9250_CONFIG_LOG_BITS_DEFAULT + { __x86_64_accton_csp9250_config_STRINGIFY_NAME(x86_64_accton_csp9250_CONFIG_LOG_BITS_DEFAULT), __x86_64_accton_csp9250_config_STRINGIFY_VALUE(x86_64_accton_csp9250_CONFIG_LOG_BITS_DEFAULT) }, +#else +{ x86_64_accton_csp9250_CONFIG_LOG_BITS_DEFAULT(__x86_64_accton_csp9250_config_STRINGIFY_NAME), "__undefined__" }, +#endif +#ifdef x86_64_accton_csp9250_CONFIG_LOG_CUSTOM_BITS_DEFAULT + { __x86_64_accton_csp9250_config_STRINGIFY_NAME(x86_64_accton_csp9250_CONFIG_LOG_CUSTOM_BITS_DEFAULT), __x86_64_accton_csp9250_config_STRINGIFY_VALUE(x86_64_accton_csp9250_CONFIG_LOG_CUSTOM_BITS_DEFAULT) }, +#else +{ x86_64_accton_csp9250_CONFIG_LOG_CUSTOM_BITS_DEFAULT(__x86_64_accton_csp9250_config_STRINGIFY_NAME), "__undefined__" }, +#endif +#ifdef x86_64_accton_csp9250_CONFIG_PORTING_STDLIB + { __x86_64_accton_csp9250_config_STRINGIFY_NAME(x86_64_accton_csp9250_CONFIG_PORTING_STDLIB), __x86_64_accton_csp9250_config_STRINGIFY_VALUE(x86_64_accton_csp9250_CONFIG_PORTING_STDLIB) }, +#else +{ x86_64_accton_csp9250_CONFIG_PORTING_STDLIB(__x86_64_accton_csp9250_config_STRINGIFY_NAME), "__undefined__" }, +#endif +#ifdef x86_64_accton_csp9250_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS + { __x86_64_accton_csp9250_config_STRINGIFY_NAME(x86_64_accton_csp9250_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS), __x86_64_accton_csp9250_config_STRINGIFY_VALUE(x86_64_accton_csp9250_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS) }, +#else +{ x86_64_accton_csp9250_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS(__x86_64_accton_csp9250_config_STRINGIFY_NAME), "__undefined__" }, +#endif +#ifdef x86_64_accton_csp9250_CONFIG_INCLUDE_UCLI + { __x86_64_accton_csp9250_config_STRINGIFY_NAME(x86_64_accton_csp9250_CONFIG_INCLUDE_UCLI), __x86_64_accton_csp9250_config_STRINGIFY_VALUE(x86_64_accton_csp9250_CONFIG_INCLUDE_UCLI) }, +#else +{ x86_64_accton_csp9250_CONFIG_INCLUDE_UCLI(__x86_64_accton_csp9250_config_STRINGIFY_NAME), "__undefined__" }, +#endif +#ifdef x86_64_accton_csp9250_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION + { __x86_64_accton_csp9250_config_STRINGIFY_NAME(x86_64_accton_csp9250_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION), __x86_64_accton_csp9250_config_STRINGIFY_VALUE(x86_64_accton_csp9250_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION) }, +#else +{ x86_64_accton_csp9250_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION(__x86_64_accton_csp9250_config_STRINGIFY_NAME), "__undefined__" }, +#endif + { NULL, NULL } +}; +#undef __x86_64_accton_csp9250_config_STRINGIFY_VALUE +#undef __x86_64_accton_csp9250_config_STRINGIFY_NAME + +const char* +x86_64_accton_csp9250_config_lookup(const char* setting) +{ + int i; + for(i = 0; x86_64_accton_csp9250_config_settings[i].name; i++) { + if(strcmp(x86_64_accton_csp9250_config_settings[i].name, setting)) { + return x86_64_accton_csp9250_config_settings[i].value; + } + } + return NULL; +} + +int +x86_64_accton_csp9250_config_show(struct aim_pvs_s* pvs) +{ + int i; + for(i = 0; x86_64_accton_csp9250_config_settings[i].name; i++) { + aim_printf(pvs, "%s = %s\n", x86_64_accton_csp9250_config_settings[i].name, x86_64_accton_csp9250_config_settings[i].value); + } + return i; +} + +/* */ + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_enums.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_enums.c new file mode 100755 index 00000000..9d9fda58 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_enums.c @@ -0,0 +1,10 @@ +/**************************************************************************//** + * + * + * + *****************************************************************************/ +#include + +/* <--auto.start.enum(ALL).source> */ +/* */ + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_int.h b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_int.h new file mode 100755 index 00000000..51f3f205 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_int.h @@ -0,0 +1,12 @@ +/**************************************************************************//** + * + * x86_64_accton_csp9250 Internal Header + * + *****************************************************************************/ +#ifndef __x86_64_accton_csp9250_INT_H__ +#define __x86_64_accton_csp9250_INT_H__ + +#include + + +#endif /* __x86_64_accton_csp9250_INT_H__ */ diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_log.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_log.c new file mode 100755 index 00000000..58133bcf --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_log.c @@ -0,0 +1,18 @@ +/**************************************************************************//** + * + * + * + *****************************************************************************/ +#include + +#include "x86_64_accton_csp9250_log.h" +/* + * x86_64_accton_csp9250 log struct. + */ +AIM_LOG_STRUCT_DEFINE( + x86_64_accton_csp9250_CONFIG_LOG_OPTIONS_DEFAULT, + x86_64_accton_csp9250_CONFIG_LOG_BITS_DEFAULT, + NULL, /* Custom log map */ + x86_64_accton_csp9250_CONFIG_LOG_CUSTOM_BITS_DEFAULT + ); + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_log.h b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_log.h new file mode 100755 index 00000000..a82a3299 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_log.h @@ -0,0 +1,12 @@ +/**************************************************************************//** + * + * + * + *****************************************************************************/ +#ifndef __x86_64_accton_csp9250_LOG_H__ +#define __x86_64_accton_csp9250_LOG_H__ + +#define AIM_LOG_MODULE_NAME x86_64_accton_csp9250 +#include + +#endif /* __x86_64_accton_csp9250_LOG_H__ */ diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_module.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_module.c new file mode 100755 index 00000000..75fdc6e7 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_module.c @@ -0,0 +1,24 @@ +/**************************************************************************//** + * + * + * + *****************************************************************************/ +#include + +#include "x86_64_accton_csp9250_log.h" + +static int +datatypes_init__(void) +{ +#define x86_64_accton_csp9250_ENUMERATION_ENTRY(_enum_name, _desc) AIM_DATATYPE_MAP_REGISTER(_enum_name, _enum_name##_map, _desc, AIM_LOG_INTERNAL); +#include + return 0; +} + +void __x86_64_accton_csp9250_module_init__(void) +{ + AIM_LOG_STRUCT_REGISTER(); + datatypes_init__(); +} + +int __onlp_platform_version__ = 1; diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_ucli.c b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_ucli.c new file mode 100755 index 00000000..4159759e --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/module/src/x86_64_accton_csp9250_ucli.c @@ -0,0 +1,50 @@ +/**************************************************************************//** + * + * + * + *****************************************************************************/ +#include + +#if x86_64_accton_csp9250_CONFIG_INCLUDE_UCLI == 1 + +#include +#include +#include + +static ucli_status_t +x86_64_accton_csp9250_ucli_ucli__config__(ucli_context_t* uc) +{ + UCLI_HANDLER_MACRO_MODULE_CONFIG(x86_64_accton_csp9250) +} + +/* */ +/* */ + +static ucli_module_t +x86_64_accton_csp9250_ucli_module__ = + { + "x86_64_accton_csp9250_ucli", + NULL, + x86_64_accton_csp9250_ucli_ucli_handlers__, + NULL, + NULL, + }; + +ucli_node_t* +x86_64_accton_csp9250_ucli_node_create(void) +{ + ucli_node_t* n; + ucli_module_init(&x86_64_accton_csp9250_ucli_module__); + n = ucli_node_create("x86_64_accton_csp9250", NULL, &x86_64_accton_csp9250_ucli_module__); + ucli_node_subnode_add(n, ucli_module_log_node_create("x86_64_accton_csp9250")); + return n; +} + +#else +void* +x86_64_accton_csp9250_ucli_node_create(void) +{ + return NULL; +} +#endif + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/x86_64_accton_csp9250.mk b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/x86_64_accton_csp9250.mk new file mode 100755 index 00000000..c0a81e05 --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/onlp/builds/src/x86_64_accton_csp9250.mk @@ -0,0 +1,13 @@ + +############################################################################### +# +# Inclusive Makefile for the x86_64_accton_csp9250 module. +# +# Autogenerated 2017-08-10 09:44:26.279780 +# +############################################################################### +x86_64_accton_csp9250_BASEDIR := $(dir $(abspath $(lastword $(MAKEFILE_LIST)))) +include $(x86_64_accton_csp9250_BASEDIR)module/make.mk +include $(x86_64_accton_csp9250_BASEDIR)module/src/make.mk +include $(x86_64_accton_csp9250_BASEDIR)module/auto/make.mk + diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/Makefile b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/Makefile new file mode 100755 index 00000000..003238cf --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/Makefile @@ -0,0 +1 @@ +include $(ONL)/make/pkg.mk \ No newline at end of file diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/Makefile b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/Makefile new file mode 100755 index 00000000..003238cf --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/Makefile @@ -0,0 +1 @@ +include $(ONL)/make/pkg.mk \ No newline at end of file diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/PKG.yml b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/PKG.yml new file mode 100755 index 00000000..4d70dcab --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/PKG.yml @@ -0,0 +1 @@ +!include $ONL_TEMPLATES/platform-config-platform.yml ARCH=amd64 VENDOR=accton BASENAME=x86-64-accton-csp9250 REVISION=r0 diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/src/lib/x86-64-accton-csp9250-r0.yml b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/src/lib/x86-64-accton-csp9250-r0.yml new file mode 100755 index 00000000..8425af5c --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/src/lib/x86-64-accton-csp9250-r0.yml @@ -0,0 +1,24 @@ +--- + +###################################################################### +# +# platform-config for csp9250 +# +###################################################################### + +x86-64-accton-csp9250-r0: + + grub: + serial: >- + console=tty0 + kernel: + <<: *kernel-3-16 + + args: >- + console=tty0, + + ##network + ## interfaces: + ## ma1: + ## name: ~ + ## syspath: pci0000:00/0000:00:14.0 diff --git a/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/src/python/x86_64_accton_csp9250_r0/__init__.py b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/src/python/x86_64_accton_csp9250_r0/__init__.py new file mode 100755 index 00000000..1650277e --- /dev/null +++ b/packages/platforms/accton/x86-64/x86-64-accton-csp9250/platform-config/r0/src/python/x86_64_accton_csp9250_r0/__init__.py @@ -0,0 +1,108 @@ +from onl.platform.base import * +from onl.platform.accton import * + +class OnlPlatform_x86_64_accton_csp9250_r0(OnlPlatformAccton, + OnlPlatformPortConfig_48x25_6x100): + + PLATFORM='x86-64-accton-csp9250-r0' + MODEL="csp9250" + SYS_OBJECT_ID=".csp9250.54" + + def baseconfig(self): + self.insmod('ym2651y') + for m in [ 'cpld', 'sfp', 'leds' ]: + self.insmod("x86-64-accton-csp9250-%s.ko" % m) + + ########### initialize I2C bus 0 ########### + + # initiate multiplexer (PCA9548) + self.new_i2c_devices( + [ + # initiate multiplexer (PCA9548) + ('pca9548', 0x71, 0), + ('pca9548', 0x70, 0), + ('pca9548', 0x72, 0), + ('pca9548', 0x73, 0), + ('pca9548', 0x74, 0), + ('pca9548', 0x75, 0), + ('pca9548', 0x76, 0), + ('pca9548', 0x77, 0), + ] + ) + + self.new_i2c_devices([ + # initialize CPLD + ('accton_i2c_cpld', 0x60, 1), + ('accton_i2c_cpld', 0x62, 2), + ('accton_i2c_cpld', 0x64, 3), + ]) + + # initialize QSFP port 1~54 + self.new_i2c_devices( + [ + ('csp9250_sfp1', 0x50, 17), + ('csp9250_sfp2', 0x50, 18), + ('csp9250_sfp3', 0x50, 19), + ('csp9250_sfp4', 0x50, 20), + ('csp9250_sfp5', 0x50, 21), + ('csp9250_sfp6', 0x50, 22), + ('csp9250_sfp7', 0x50, 23), + ('csp9250_sfp8', 0x50, 24), + + ('csp9250_sfp9' , 0x50, 25), + ('csp9250_sfp10', 0x50, 26), + ('csp9250_sfp11', 0x50, 27), + ('csp9250_sfp12', 0x50, 28), + ('csp9250_sfp13', 0x50, 29), + ('csp9250_sfp14', 0x50, 30), + ('csp9250_sfp15', 0x50, 31), + ('csp9250_sfp16', 0x50, 32), + + ('csp9250_sfp17', 0x50, 33), + ('csp9250_sfp18', 0x50, 34), + ('csp9250_sfp19', 0x50, 35), + ('csp9250_sfp20', 0x50, 36), + ('csp9250_sfp21', 0x50, 37), + ('csp9250_sfp22', 0x50, 38), + ('csp9250_sfp23', 0x50, 39), + ('csp9250_sfp24', 0x50, 40), + + ('csp9250_sfp25', 0x50, 41), + ('csp9250_sfp26', 0x50, 42), + ('csp9250_sfp27', 0x50, 43), + ('csp9250_sfp28', 0x50, 44), + ('csp9250_sfp29', 0x50, 45), + ('csp9250_sfp30', 0x50, 46), + ('csp9250_sfp31', 0x50, 47), + ('csp9250_sfp32', 0x50, 48), + + ('csp9250_sfp33', 0x50, 49), + ('csp9250_sfp34', 0x50, 50), + ('csp9250_sfp35', 0x50, 51), + ('csp9250_sfp36', 0x50, 52), + ('csp9250_sfp37', 0x50, 53), + ('csp9250_sfp38', 0x50, 54), + ('csp9250_sfp39', 0x50, 55), + ('csp9250_sfp40', 0x50, 56), + ('csp9250_sfp41', 0x50, 57), + ('csp9250_sfp42', 0x50, 58), + + ('csp9250_sfp43', 0x50, 59), + ('csp9250_sfp44', 0x50, 60), + ('csp9250_sfp45', 0x50, 61), + ('csp9250_sfp46', 0x50, 62), + ('csp9250_sfp47', 0x50, 63), + ('csp9250_sfp48', 0x50, 64), + + ('csp9250_sfp49', 0x50, 9), + ('csp9250_sfp50', 0x50, 10), + ('csp9250_sfp51', 0x50, 11), + ('csp9250_sfp52', 0x50, 12), + ('csp9250_sfp53', 0x50, 13), + ('csp9250_sfp54', 0x50, 14), + ] + ) + + return True + +