scottk/OpenNetworkLinux
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/OpenNetworkLinux.git synced 2025-12-25 17:27:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Normalize Platform AS7712-32X.

Browse Source 
- Shorted to as7712-32x based on existing vendor/arch/ structure.
- Rename the module directory.
This commit is contained in:
Jeffrey Townsend
2018-08-08 00:28:45 +00:00
parent edc7c652b8
commit 8b95f20d52
51 changed files with 4368 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
packages/platforms/accton/x86-64/as7712-32x/.gitignore vendored Normal file
View File

@@ -0,0 +1,3 @@
*x86*64*accton*as7712*32x*.mk
onlpdump.mk

1
packages/platforms/accton/x86-64/as7712-32x/Makefile Normal file
View File

@@ -0,0 +1 @@
include $(ONL)/make/pkg.mk

1
packages/platforms/accton/x86-64/as7712-32x/modules/Makefile Normal file
View File

@@ -0,0 +1 @@
include $(ONL)/make/pkg.mk

1
packages/platforms/accton/x86-64/as7712-32x/modules/PKG.yml Normal file
View File

@@ -0,0 +1 @@
!include $ONL_TEMPLATES/platform-modules.yml VENDOR=accton BASENAME=x86-64-accton-as7712-32x ARCH=amd64 KERNELS="onl-kernel-4.14-lts-x86-64-all:amd64"

1
packages/platforms/accton/x86-64/as7712-32x/modules/builds/.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
lib

6
packages/platforms/accton/x86-64/as7712-32x/modules/builds/Makefile Normal file
View File

@@ -0,0 +1,6 @@
KERNELS := onl-kernel-4.14-lts-x86-64-all:amd64
KMODULES := $(wildcard *.c)
VENDOR := accton
BASENAME := x86-64-accton-as7712-32x
ARCH := x86_64
include $(ONL)/make/kmodule.mk

558
packages/platforms/accton/x86-64/as7712-32x/modules/builds/x86-64-accton-as7712-32x-cpld1.c Normal file
View File

@@ -0,0 +1,558 @@
/*
* A hwmon driver for the as7712_32x_cpld
*
* Copyright (C) 2013 Accton Technology Corporation.
* Brandon Chuang <brandon_chuang@accton.com.tw>
*
* Based on ad7414.c
* Copyright 2006 Stefan Roese <sr at denx.de>, 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 <linux/module.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/sysfs.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/list.h>
static LIST_HEAD(cpld_client_list);
static struct mutex list_lock;
struct cpld_client_node {
struct i2c_client *client;
struct list_head list;
};
#define I2C_RW_RETRY_COUNT 10
#define I2C_RW_RETRY_INTERVAL 60 /* ms */
static ssize_t show_present(struct device *dev, struct device_attribute *da,
char *buf);
static ssize_t show_present_all(struct device *dev, struct device_attribute *da,
char *buf);
static ssize_t access(struct device *dev, struct device_attribute *da,
const char *buf, size_t count);
static ssize_t show_version(struct device *dev, struct device_attribute *da,
char *buf);
static int as7712_32x_cpld_read_internal(struct i2c_client *client, u8 reg);
static int as7712_32x_cpld_write_internal(struct i2c_client *client, u8 reg, u8 value);
struct as7712_32x_cpld_data {
struct device *hwmon_dev;
struct mutex update_lock;
};
/* Addresses scanned for as7712_32x_cpld
*/
static const unsigned short normal_i2c[] = { I2C_CLIENT_END };
#define TRANSCEIVER_PRESENT_ATTR_ID(index) MODULE_PRESENT_##index
enum as7712_32x_cpld_sysfs_attributes {
CPLD_VERSION,
ACCESS,
MODULE_PRESENT_ALL,
/* transceiver attributes */
TRANSCEIVER_PRESENT_ATTR_ID(1),
TRANSCEIVER_PRESENT_ATTR_ID(2),
TRANSCEIVER_PRESENT_ATTR_ID(3),
TRANSCEIVER_PRESENT_ATTR_ID(4),
TRANSCEIVER_PRESENT_ATTR_ID(5),
TRANSCEIVER_PRESENT_ATTR_ID(6),
TRANSCEIVER_PRESENT_ATTR_ID(7),
TRANSCEIVER_PRESENT_ATTR_ID(8),
TRANSCEIVER_PRESENT_ATTR_ID(9),
TRANSCEIVER_PRESENT_ATTR_ID(10),
TRANSCEIVER_PRESENT_ATTR_ID(11),
TRANSCEIVER_PRESENT_ATTR_ID(12),
TRANSCEIVER_PRESENT_ATTR_ID(13),
TRANSCEIVER_PRESENT_ATTR_ID(14),
TRANSCEIVER_PRESENT_ATTR_ID(15),
TRANSCEIVER_PRESENT_ATTR_ID(16),
TRANSCEIVER_PRESENT_ATTR_ID(17),
TRANSCEIVER_PRESENT_ATTR_ID(18),
TRANSCEIVER_PRESENT_ATTR_ID(19),
TRANSCEIVER_PRESENT_ATTR_ID(20),
TRANSCEIVER_PRESENT_ATTR_ID(21),
TRANSCEIVER_PRESENT_ATTR_ID(22),
TRANSCEIVER_PRESENT_ATTR_ID(23),
TRANSCEIVER_PRESENT_ATTR_ID(24),
TRANSCEIVER_PRESENT_ATTR_ID(25),
TRANSCEIVER_PRESENT_ATTR_ID(26),
TRANSCEIVER_PRESENT_ATTR_ID(27),
TRANSCEIVER_PRESENT_ATTR_ID(28),
TRANSCEIVER_PRESENT_ATTR_ID(29),
TRANSCEIVER_PRESENT_ATTR_ID(30),
TRANSCEIVER_PRESENT_ATTR_ID(31),
TRANSCEIVER_PRESENT_ATTR_ID(32),
};
/* sysfs attributes for hwmon
*/
/* transceiver attributes */
#define DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(index) \
static SENSOR_DEVICE_ATTR(module_present_##index, S_IRUGO, show_present, NULL, MODULE_PRESENT_##index)
#define DECLARE_TRANSCEIVER_ATTR(index) &sensor_dev_attr_module_present_##index.dev_attr.attr
static SENSOR_DEVICE_ATTR(version, S_IRUGO, show_version, NULL, CPLD_VERSION);
static SENSOR_DEVICE_ATTR(access, S_IWUSR, NULL, access, ACCESS);
/* transceiver attributes */
static SENSOR_DEVICE_ATTR(module_present_all, S_IRUGO, show_present_all, NULL, MODULE_PRESENT_ALL);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(1);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(2);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(3);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(4);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(5);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(6);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(7);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(8);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(9);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(10);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(11);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(12);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(13);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(14);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(15);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(16);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(17);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(18);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(19);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(20);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(21);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(22);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(23);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(24);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(25);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(26);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(27);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(28);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(29);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(30);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(31);
DECLARE_TRANSCEIVER_SENSOR_DEVICE_ATTR(32);
static struct attribute *as7712_32x_cpld_attributes[] = {
&sensor_dev_attr_version.dev_attr.attr,
&sensor_dev_attr_access.dev_attr.attr,
/* transceiver attributes */
&sensor_dev_attr_module_present_all.dev_attr.attr,
DECLARE_TRANSCEIVER_ATTR(1),
DECLARE_TRANSCEIVER_ATTR(2),
DECLARE_TRANSCEIVER_ATTR(3),
DECLARE_TRANSCEIVER_ATTR(4),
DECLARE_TRANSCEIVER_ATTR(5),
DECLARE_TRANSCEIVER_ATTR(6),
DECLARE_TRANSCEIVER_ATTR(7),
DECLARE_TRANSCEIVER_ATTR(8),
DECLARE_TRANSCEIVER_ATTR(9),
DECLARE_TRANSCEIVER_ATTR(10),
DECLARE_TRANSCEIVER_ATTR(11),
DECLARE_TRANSCEIVER_ATTR(12),
DECLARE_TRANSCEIVER_ATTR(13),
DECLARE_TRANSCEIVER_ATTR(14),
DECLARE_TRANSCEIVER_ATTR(15),
DECLARE_TRANSCEIVER_ATTR(16),
DECLARE_TRANSCEIVER_ATTR(17),
DECLARE_TRANSCEIVER_ATTR(18),
DECLARE_TRANSCEIVER_ATTR(19),
DECLARE_TRANSCEIVER_ATTR(20),
DECLARE_TRANSCEIVER_ATTR(21),
DECLARE_TRANSCEIVER_ATTR(22),
DECLARE_TRANSCEIVER_ATTR(23),
DECLARE_TRANSCEIVER_ATTR(24),
DECLARE_TRANSCEIVER_ATTR(25),
DECLARE_TRANSCEIVER_ATTR(26),
DECLARE_TRANSCEIVER_ATTR(27),
DECLARE_TRANSCEIVER_ATTR(28),
DECLARE_TRANSCEIVER_ATTR(29),
DECLARE_TRANSCEIVER_ATTR(30),
DECLARE_TRANSCEIVER_ATTR(31),
DECLARE_TRANSCEIVER_ATTR(32),
NULL
};
static const struct attribute_group as7712_32x_cpld_group = {
.attrs = as7712_32x_cpld_attributes,
};
static ssize_t show_present_all(struct device *dev, struct device_attribute *da,
char *buf)
{
int i, status;
u8 values[4] = {0};
u8 regs[] = {0x30, 0x31, 0x32, 0x33};
struct i2c_client *client = to_i2c_client(dev);
struct as7712_32x_cpld_data *data = i2c_get_clientdata(client);
mutex_lock(&data->update_lock);
for (i = 0; i < ARRAY_SIZE(regs); i++) {
status = as7712_32x_cpld_read_internal(client, regs[i]);
if (status < 0) {
goto exit;
}
values[i] = ~(u8)status;
}
mutex_unlock(&data->update_lock);
/* Return values 1 -> 32 in order */
return sprintf(buf, "%.2x %.2x %.2x %.2x\n",
values[0], values[1], values[2],
values[3]);
exit:
mutex_unlock(&data->update_lock);
return status;
}
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);
struct as7712_32x_cpld_data *data = i2c_get_clientdata(client);
int status = 0;
u8 reg = 0, mask = 0;
switch (attr->index) {
case MODULE_PRESENT_1 ... MODULE_PRESENT_8:
reg = 0x30;
mask = 0x1 << (attr->index - MODULE_PRESENT_1);
break;
case MODULE_PRESENT_9 ... MODULE_PRESENT_16:
reg = 0x31;
mask = 0x1 << (attr->index - MODULE_PRESENT_9);
break;
case MODULE_PRESENT_17 ... MODULE_PRESENT_24:
reg = 0x32;
mask = 0x1 << (attr->index - MODULE_PRESENT_17);
break;
case MODULE_PRESENT_25 ... MODULE_PRESENT_32:
reg = 0x33;
mask = 0x1 << (attr->index - MODULE_PRESENT_25);
break;
default:
return 0;
}
mutex_lock(&data->update_lock);
status = as7712_32x_cpld_read_internal(client, reg);
if (unlikely(status < 0)) {
goto exit;
}
mutex_unlock(&data->update_lock);
return sprintf(buf, "%d\n", !(status & mask));
exit:
mutex_unlock(&data->update_lock);
return status;
}
static ssize_t show_version(struct device *dev, struct device_attribute *da,
char *buf)
{
u8 reg = 0, mask = 0;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct i2c_client *client = to_i2c_client(dev);
struct as7712_32x_cpld_data *data = i2c_get_clientdata(client);
int status = 0;
switch (attr->index) {
case CPLD_VERSION:
reg = 0x1;
mask = 0xFF;
break;
default:
break;
}
mutex_lock(&data->update_lock);
status = as7712_32x_cpld_read_internal(client, reg);
if (unlikely(status < 0)) {
goto exit;
}
mutex_unlock(&data->update_lock);
return sprintf(buf, "%d\n", (status & mask));
exit:
mutex_unlock(&data->update_lock);
return status;
}
static ssize_t access(struct device *dev, struct device_attribute *da,
const char *buf, size_t count)
{
int status;
u32 addr, val;
struct i2c_client *client = to_i2c_client(dev);
struct as7712_32x_cpld_data *data = i2c_get_clientdata(client);
if (sscanf(buf, "0x%x 0x%x", &addr, &val) != 2) {
return -EINVAL;
}
if (addr > 0xFF || val > 0xFF) {
return -EINVAL;
}
mutex_lock(&data->update_lock);
status = as7712_32x_cpld_write_internal(client, addr, val);
if (unlikely(status < 0)) {
goto exit;
}
mutex_unlock(&data->update_lock);
return count;
exit:
mutex_unlock(&data->update_lock);
return status;
}
static int as7712_32x_cpld_read_internal(struct i2c_client *client, u8 reg)
{
int status = 0, retry = I2C_RW_RETRY_COUNT;
while (retry) {
status = i2c_smbus_read_byte_data(client, reg);
if (unlikely(status < 0)) {
msleep(I2C_RW_RETRY_INTERVAL);
retry--;
continue;
}
break;
}
return status;
}
static int as7712_32x_cpld_write_internal(struct i2c_client *client, u8 reg, u8 value)
{
int status = 0, retry = I2C_RW_RETRY_COUNT;
while (retry) {
status = i2c_smbus_write_byte_data(client, reg, value);
if (unlikely(status < 0)) {
msleep(I2C_RW_RETRY_INTERVAL);
retry--;
continue;
}
break;
}
return status;
}
static void as7712_32x_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 as7712_32x_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 as7712_32x_cpld_probe(struct i2c_client *client,
const struct i2c_device_id *dev_id)
{
int status;
struct as7712_32x_cpld_data *data = NULL;
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;
}
data = kzalloc(sizeof(struct as7712_32x_cpld_data), GFP_KERNEL);
if (!data) {
status = -ENOMEM;
goto exit;
}
i2c_set_clientdata(client, data);
mutex_init(&data->update_lock);
dev_info(&client->dev, "chip found\n");
/* Register sysfs hooks */
status = sysfs_create_group(&client->dev.kobj, &as7712_32x_cpld_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;
}
as7712_32x_cpld_add_client(client);
dev_info(&client->dev, "%s: cpld '%s'\n",
dev_name(data->hwmon_dev), client->name);
return 0;
exit_remove:
sysfs_remove_group(&client->dev.kobj, &as7712_32x_cpld_group);
exit_free:
kfree(data);
exit:
return status;
}
static int as7712_32x_cpld_remove(struct i2c_client *client)
{
struct as7712_32x_cpld_data *data = i2c_get_clientdata(client);
hwmon_device_unregister(data->hwmon_dev);
sysfs_remove_group(&client->dev.kobj, &as7712_32x_cpld_group);
kfree(data);
as7712_32x_cpld_remove_client(client);
return 0;
}
int as7712_32x_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(as7712_32x_cpld_read);
int as7712_32x_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(as7712_32x_cpld_write);
static const struct i2c_device_id as7712_32x_cpld_id[] = {
{ "as7712_32x_cpld1", 0 },
{}
};
MODULE_DEVICE_TABLE(i2c, as7712_32x_cpld_id);
static struct i2c_driver as7712_32x_cpld_driver = {
.class = I2C_CLASS_HWMON,
.driver = {
.name = "as7712_32x_cpld1",
},
.probe = as7712_32x_cpld_probe,
.remove = as7712_32x_cpld_remove,
.id_table = as7712_32x_cpld_id,
.address_list = normal_i2c,
};
static int __init as7712_32x_cpld_init(void)
{
mutex_init(&list_lock);
return i2c_add_driver(&as7712_32x_cpld_driver);
}
static void __exit as7712_32x_cpld_exit(void)
{
i2c_del_driver(&as7712_32x_cpld_driver);
}
module_init(as7712_32x_cpld_init);
module_exit(as7712_32x_cpld_exit);
MODULE_AUTHOR("Brandon Chuang <brandon_chuang@accton.com.tw>");
MODULE_DESCRIPTION("as7712_32x_cpld driver");
MODULE_LICENSE("GPL");

491
packages/platforms/accton/x86-64/as7712-32x/modules/builds/x86-64-accton-as7712-32x-fan.c Normal file
View File

@@ -0,0 +1,491 @@
/*
* A hwmon driver for the Accton as7712 32x fan
*
* Copyright (C) 2014 Accton Technology Corporation.
* Brandon Chuang <brandon_chuang@accton.com.tw>
*
* 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 <linux/module.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/sysfs.h>
#include <linux/slab.h>
#include <linux/dmi.h>
#define DRVNAME "as7712_32x_fan"
static struct as7712_32x_fan_data *as7712_32x_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 accton_i2c_cpld_read(unsigned short cpld_addr, u8 reg);
extern int accton_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:B2F 1:F2B) */
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 as7712_32x_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 *as7712_32x_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 as7712_32x_fan_read_value(struct i2c_client *client, u8 reg)
{
return i2c_smbus_read_byte_data(client, reg);
}
static int as7712_32x_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 as7712_32x_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;
as7712_32x_fan_write_value(client, 0x33, 0); /* Disable fan speed watch dog */
as7712_32x_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 as7712_32x_fan_data *data = as7712_32x_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 as7712_32x_fan_group = {
.attrs = as7712_32x_fan_attributes,
};
static struct as7712_32x_fan_data *as7712_32x_fan_update_device(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct as7712_32x_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 as7712_32x_fan update\n");
data->valid = 0;
/* Update fan data
*/
for (i = 0; i < ARRAY_SIZE(data->reg_val); i++) {
int status = as7712_32x_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 as7712_32x_fan_probe(struct i2c_client *client,
const struct i2c_device_id *dev_id)
{
struct as7712_32x_fan_data *data;
int status;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
status = -EIO;
goto exit;
}
data = kzalloc(sizeof(struct as7712_32x_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, &as7712_32x_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, &as7712_32x_fan_group);
exit_free:
kfree(data);
exit:
return status;
}
static int as7712_32x_fan_remove(struct i2c_client *client)
{
struct as7712_32x_fan_data *data = i2c_get_clientdata(client);
hwmon_device_unregister(data->hwmon_dev);
sysfs_remove_group(&client->dev.kobj, &as7712_32x_fan_group);
return 0;
}
/* Addresses to scan */
static const unsigned short normal_i2c[] = { 0x66, I2C_CLIENT_END };
static const struct i2c_device_id as7712_32x_fan_id[] = {
{ "as7712_32x_fan", 0 },
{}
};
MODULE_DEVICE_TABLE(i2c, as7712_32x_fan_id);
static struct i2c_driver as7712_32x_fan_driver = {
.class = I2C_CLASS_HWMON,
.driver = {
.name = DRVNAME,
},
.probe = as7712_32x_fan_probe,
.remove = as7712_32x_fan_remove,
.id_table = as7712_32x_fan_id,
.address_list = normal_i2c,
};
static int __init as7712_32x_fan_init(void)
{
extern int platform_accton_as7712_32x(void);
if (!platform_accton_as7712_32x()) {
return -ENODEV;
}
return i2c_add_driver(&as7712_32x_fan_driver);
}
static void __exit as7712_32x_fan_exit(void)
{
i2c_del_driver(&as7712_32x_fan_driver);
}
module_init(as7712_32x_fan_init);
module_exit(as7712_32x_fan_exit);
MODULE_AUTHOR("Brandon Chuang <brandon_chuang@accton.com.tw>");
MODULE_DESCRIPTION("as7712_32x_fan driver");
MODULE_LICENSE("GPL");

438
packages/platforms/accton/x86-64/as7712-32x/modules/builds/x86-64-accton-as7712-32x-leds.c Normal file
View File

@@ -0,0 +1,438 @@
/*
* A LED driver for the accton_as7712_32x_led
*
* Copyright (C) 2014 Accton Technology Corporation.
* Brandon Chuang <brandon_chuang@accton.com.tw>
*
* 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 <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/err.h>
#include <linux/leds.h>
#include <linux/slab.h>
#include <linux/dmi.h>
extern int as7712_32x_cpld_read (unsigned short cpld_addr, u8 reg);
extern int as7712_32x_cpld_write(unsigned short cpld_addr, u8 reg, u8 value);
#define DRVNAME "accton_as7712_32x_led"
struct accton_as7712_32x_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_as7712_32x_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<<LED_TYPE_LOC) | (1<<LED_TYPE_DIAG), 0x41},
};
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
};
struct led_type_mode {
enum led_type type;
enum led_light_mode mode;
int reg_bit_mask;
int mode_value;
};
static struct led_type_mode led_type_mode_data[] = {
{LED_TYPE_LOC, LED_MODE_OFF, LED_TYPE_LOC_REG_MASK, LED_MODE_LOC_OFF_VALUE},
{LED_TYPE_LOC, LED_MODE_BLUE, LED_TYPE_LOC_REG_MASK, LED_MODE_LOC_ON_VALUE},
{LED_TYPE_DIAG, LED_MODE_OFF, LED_TYPE_DIAG_REG_MASK, LED_MODE_DIAG_OFF_VALUE},
{LED_TYPE_DIAG, LED_MODE_GREEN, LED_TYPE_DIAG_REG_MASK, LED_MODE_DIAG_GREEN_VALUE},
{LED_TYPE_DIAG, LED_MODE_RED, LED_TYPE_DIAG_REG_MASK, LED_MODE_DIAG_RED_VALUE},
{LED_TYPE_DIAG, LED_MODE_AMBER, LED_TYPE_DIAG_REG_MASK, LED_MODE_DIAG_AMBER_VALUE},
};
static void accton_as7712_32x_led_set(struct led_classdev *led_cdev,
enum led_brightness led_light_mode, enum led_type type);
static int accton_getLedReg(enum led_type type, u8 *reg)
{
int i;
for (i = 0; i < ARRAY_SIZE(led_reg_map); i++) {
if(led_reg_map[i].types & (type<<1)){
*reg = led_reg_map[i].reg_addr;
return 0;
}
}
return 1;
}
static int led_reg_val_to_light_mode(enum led_type type, u8 reg_val) {
int i;
for (i = 0; i < ARRAY_SIZE(led_type_mode_data); i++) {
if (type != led_type_mode_data[i].type)
continue;
if ((led_type_mode_data[i].reg_bit_mask & reg_val) ==
led_type_mode_data[i].mode_value)
{
return led_type_mode_data[i].mode;
}
}
return 0;
}
static u8 led_light_mode_to_reg_val(enum led_type type,
enum led_light_mode mode, u8 reg_val) {
int i;
for (i = 0; i < ARRAY_SIZE(led_type_mode_data); i++) {
if (type != led_type_mode_data[i].type)
continue;
if (mode != led_type_mode_data[i].mode)
continue;
reg_val = led_type_mode_data[i].mode_value |
(reg_val & (~led_type_mode_data[i].reg_bit_mask));
break;
}
return reg_val;
}
static int accton_as7712_32x_led_read_value(u8 reg)
{
return as7712_32x_cpld_read(LED_CNTRLER_I2C_ADDRESS, reg);
}
static int accton_as7712_32x_led_write_value(u8 reg, u8 value)
{
return as7712_32x_cpld_write(LED_CNTRLER_I2C_ADDRESS, reg, value);
}
static void accton_as7712_32x_led_update(void)
{
mutex_lock(&ledctl->update_lock);
if (time_after(jiffies, ledctl->last_updated + HZ + HZ / 2)
|| !ledctl->valid) {
int i;
dev_dbg(&ledctl->pdev->dev, "Starting accton_as7712_32x_led update\n");
/* Update LED data
*/
for (i = 0; i < ARRAY_SIZE(ledctl->reg_val); i++) {
int status = accton_as7712_32x_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_as7712_32x_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, &reg))
{
dev_dbg(&ledctl->pdev->dev, "Not match item for %d.\n", type);
}
reg_val = accton_as7712_32x_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_as7712_32x_led_write_value(reg, reg_val);
/* to prevent the slow-update issue */
ledctl->valid = 0;
exit:
mutex_unlock(&ledctl->update_lock);
}
static void accton_as7712_32x_led_diag_set(struct led_classdev *led_cdev,
enum led_brightness led_light_mode)
{
accton_as7712_32x_led_set(led_cdev, led_light_mode, LED_TYPE_DIAG);
}
static enum led_brightness accton_as7712_32x_led_diag_get(struct led_classdev *cdev)
{
accton_as7712_32x_led_update();
return led_reg_val_to_light_mode(LED_TYPE_DIAG, ledctl->reg_val[0]);
}
static void accton_as7712_32x_led_loc_set(struct led_classdev *led_cdev,
enum led_brightness led_light_mode)
{
accton_as7712_32x_led_set(led_cdev, led_light_mode, LED_TYPE_LOC);
}
static enum led_brightness accton_as7712_32x_led_loc_get(struct led_classdev *cdev)
{
accton_as7712_32x_led_update();
return led_reg_val_to_light_mode(LED_TYPE_LOC, ledctl->reg_val[0]);
}
static void accton_as7712_32x_led_auto_set(struct led_classdev *led_cdev,
enum led_brightness led_light_mode)
{
}
static enum led_brightness accton_as7712_32x_led_auto_get(struct led_classdev *cdev)
{
return LED_MODE_AUTO;
}
static struct led_classdev accton_as7712_32x_leds[] = {
[LED_TYPE_DIAG] = {
.name = "accton_as7712_32x_led::diag",
.default_trigger = "unused",
.brightness_set = accton_as7712_32x_led_diag_set,
.brightness_get = accton_as7712_32x_led_diag_get,
.flags = LED_CORE_SUSPENDRESUME,
.max_brightness = LED_MODE_RED,
},
[LED_TYPE_LOC] = {
.name = "accton_as7712_32x_led::loc",
.default_trigger = "unused",
.brightness_set = accton_as7712_32x_led_loc_set,
.brightness_get = accton_as7712_32x_led_loc_get,
.flags = LED_CORE_SUSPENDRESUME,
.max_brightness = LED_MODE_BLUE,
},
[LED_TYPE_FAN] = {
.name = "accton_as7712_32x_led::fan",
.default_trigger = "unused",
.brightness_set = accton_as7712_32x_led_auto_set,
.brightness_get = accton_as7712_32x_led_auto_get,
.flags = LED_CORE_SUSPENDRESUME,
.max_brightness = LED_MODE_AUTO,
},
[LED_TYPE_PSU1] = {
.name = "accton_as7712_32x_led::psu1",
.default_trigger = "unused",
.brightness_set = accton_as7712_32x_led_auto_set,
.brightness_get = accton_as7712_32x_led_auto_get,
.flags = LED_CORE_SUSPENDRESUME,
.max_brightness = LED_MODE_AUTO,
},
[LED_TYPE_PSU2] = {
.name = "accton_as7712_32x_led::psu2",
.default_trigger = "unused",
.brightness_set = accton_as7712_32x_led_auto_set,
.brightness_get = accton_as7712_32x_led_auto_get,
.flags = LED_CORE_SUSPENDRESUME,
.max_brightness = LED_MODE_AUTO,
},
};
static int accton_as7712_32x_led_suspend(struct platform_device *dev,
pm_message_t state)
{
int i = 0;
for (i = 0; i < ARRAY_SIZE(accton_as7712_32x_leds); i++) {
led_classdev_suspend(&accton_as7712_32x_leds[i]);
}
return 0;
}
static int accton_as7712_32x_led_resume(struct platform_device *dev)
{
int i = 0;
for (i = 0; i < ARRAY_SIZE(accton_as7712_32x_leds); i++) {
led_classdev_resume(&accton_as7712_32x_leds[i]);
}
return 0;
}
static int accton_as7712_32x_led_probe(struct platform_device *pdev)
{
int ret, i;
for (i = 0; i < ARRAY_SIZE(accton_as7712_32x_leds); i++) {
ret = led_classdev_register(&pdev->dev, &accton_as7712_32x_leds[i]);
if (ret < 0)
break;
}
/* Check if all LEDs were successfully registered */
if (i != ARRAY_SIZE(accton_as7712_32x_leds)){
int j;
/* only unregister the LEDs that were successfully registered */
for (j = 0; j < i; j++) {
led_classdev_unregister(&accton_as7712_32x_leds[i]);
}
}
return ret;
}
static int accton_as7712_32x_led_remove(struct platform_device *pdev)
{
int i;
for (i = 0; i < ARRAY_SIZE(accton_as7712_32x_leds); i++) {
led_classdev_unregister(&accton_as7712_32x_leds[i]);
}
return 0;
}
static struct platform_driver accton_as7712_32x_led_driver = {
.probe = accton_as7712_32x_led_probe,
.remove = accton_as7712_32x_led_remove,
.suspend = accton_as7712_32x_led_suspend,
.resume = accton_as7712_32x_led_resume,
.driver = {
.name = DRVNAME,
.owner = THIS_MODULE,
},
};
static int __init accton_as7712_32x_led_init(void)
{
int ret;
extern int platform_accton_as7712_32x(void);
if (!platform_accton_as7712_32x()) {
return -ENODEV;
}
ret = platform_driver_register(&accton_as7712_32x_led_driver);
if (ret < 0) {
goto exit;
}
ledctl = kzalloc(sizeof(struct accton_as7712_32x_led_data), GFP_KERNEL);
if (!ledctl) {
ret = -ENOMEM;
platform_driver_unregister(&accton_as7712_32x_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_as7712_32x_led_driver);
kfree(ledctl);
goto exit;
}
exit:
return ret;
}
static void __exit accton_as7712_32x_led_exit(void)
{
platform_device_unregister(ledctl->pdev);
platform_driver_unregister(&accton_as7712_32x_led_driver);
kfree(ledctl);
}
module_init(accton_as7712_32x_led_init);
module_exit(accton_as7712_32x_led_exit);
MODULE_AUTHOR("Brandon Chuang <brandon_chuang@accton.com.tw>");
MODULE_DESCRIPTION("accton_as7712_32x_led driver");
MODULE_LICENSE("GPL");

384
packages/platforms/accton/x86-64/as7712-32x/modules/builds/x86-64-accton-as7712-32x-psu.c Normal file
View File

@@ -0,0 +1,384 @@
/*
* An hwmon driver for accton as7712_32x Power Module
*
* Copyright (C) 2014 Accton Technology Corporation.
* Brandon Chuang <brandon_chuang@accton.com.tw>
*
* Based on ad7414.c
* Copyright 2006 Stefan Roese <sr at denx.de>, 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 <linux/module.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/sysfs.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/dmi.h>
#define MAX_MODEL_NAME 16
#define DC12V_FAN_DIR_OFFSET 0x34
#define DC12V_FAN_DIR_LEN 3
static ssize_t show_status(struct device *dev, struct device_attribute *da, char *buf);
static int as7712_32x_psu_read_block(struct i2c_client *client, u8 command, u8 *data,int data_len);
extern int as7712_32x_cpld_read (unsigned short cpld_addr, u8 reg);
/* Addresses scanned
*/
static const unsigned short normal_i2c[] = { I2C_CLIENT_END };
/* Each client has this additional data
*/
struct as7712_32x_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[MAX_MODEL_NAME]; /* Model name, read from eeprom */
char fan_dir[DC12V_FAN_DIR_LEN+1]; /* DC12V fan direction */
};
static ssize_t show_string(struct device *dev, struct device_attribute *da, char *buf);
static struct as7712_32x_psu_data *as7712_32x_psu_update_device(struct device *dev);
enum as7712_32x_psu_sysfs_attributes {
PSU_PRESENT,
PSU_MODEL_NAME,
PSU_POWER_GOOD,
PSU_FAN_DIR /* For DC12V only */
};
/* 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_string, NULL, PSU_MODEL_NAME);
static SENSOR_DEVICE_ATTR(psu_power_good, S_IRUGO, show_status, NULL, PSU_POWER_GOOD);
static SENSOR_DEVICE_ATTR(psu_fan_dir, S_IRUGO, show_string, NULL, PSU_FAN_DIR);
static struct attribute *as7712_32x_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,
&sensor_dev_attr_psu_fan_dir.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 as7712_32x_psu_data *data = as7712_32x_psu_update_device(dev);
u8 status = 0;
if (!data->valid) {
return -EIO;
}
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_string(struct device *dev, struct device_attribute *da,
char *buf)
{
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct as7712_32x_psu_data *data = as7712_32x_psu_update_device(dev);
char *ptr = NULL;
if (!data->valid) {
return -EIO;
}
if (attr->index == PSU_MODEL_NAME) {
ptr = data->model_name;
}
else { /* PSU_FAN_DIR */
ptr = data->fan_dir;
}
return sprintf(buf, "%s\n", ptr);
}
static const struct attribute_group as7712_32x_psu_group = {
.attrs = as7712_32x_psu_attributes,
};
static int as7712_32x_psu_probe(struct i2c_client *client,
const struct i2c_device_id *dev_id)
{
struct as7712_32x_psu_data *data;
int status;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
status = -EIO;
goto exit;
}
data = kzalloc(sizeof(struct as7712_32x_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, &as7712_32x_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, &as7712_32x_psu_group);
exit_free:
kfree(data);
exit:
return status;
}
static int as7712_32x_psu_remove(struct i2c_client *client)
{
struct as7712_32x_psu_data *data = i2c_get_clientdata(client);
hwmon_device_unregister(data->hwmon_dev);
sysfs_remove_group(&client->dev.kobj, &as7712_32x_psu_group);
kfree(data);
return 0;
}
enum psu_index
{
as7712_32x_psu1,
as7712_32x_psu2
};
static const struct i2c_device_id as7712_32x_psu_id[] = {
{ "as7712_32x_psu1", as7712_32x_psu1 },
{ "as7712_32x_psu2", as7712_32x_psu2 },
{}
};
MODULE_DEVICE_TABLE(i2c, as7712_32x_psu_id);
static struct i2c_driver as7712_32x_psu_driver = {
.class = I2C_CLASS_HWMON,
.driver = {
.name = "as7712_32x_psu",
},
.probe = as7712_32x_psu_probe,
.remove = as7712_32x_psu_remove,
.id_table = as7712_32x_psu_id,
.address_list = normal_i2c,
};
static int as7712_32x_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;
}
enum psu_type {
PSU_TYPE_AC_110V,
PSU_TYPE_DC_48V,
PSU_TYPE_DC_12V
};
struct model_name_info {
enum psu_type type;
u8 offset;
u8 length;
char* model_name;
};
struct model_name_info models[] = {
{PSU_TYPE_AC_110V, 0x20, 8, "YM-2651Y"},
{PSU_TYPE_DC_48V, 0x20, 8, "YM-2651V"},
{PSU_TYPE_DC_12V, 0x00, 11, "PSU-12V-750"},
};
static int as7712_32x_psu_model_name_get(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct as7712_32x_psu_data *data = i2c_get_clientdata(client);
int i, status;
for (i = 0; i < ARRAY_SIZE(models); i++) {
memset(data->model_name, 0, sizeof(data->model_name));
status = as7712_32x_psu_read_block(client, models[i].offset,
data->model_name, models[i].length);
if (status < 0) {
data->model_name[0] = '\0';
dev_dbg(&client->dev, "unable to read model name from (0x%x) offset(0x%x)\n",
client->addr, models[i].offset);
return status;
}
else {
data->model_name[models[i].length] = '\0';
}
/* Determine if the model name is known, if not, read next index
*/
if (strncmp(data->model_name, models[i].model_name, models[i].length) == 0) {
return 0;
}
else {
data->model_name[0] = '\0';
}
}
return -ENODATA;
}
static struct as7712_32x_psu_data *as7712_32x_psu_update_device(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct as7712_32x_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;
data->valid = 0;
dev_dbg(&client->dev, "Starting as7712_32x update\n");
/* Read psu status */
status = as7712_32x_cpld_read(0x60, 0x2);
if (status < 0) {
dev_dbg(&client->dev, "cpld reg 0x60 err %d\n", status);
goto exit;
}
else {
data->status = status;
}
/* Read model name */
memset(data->model_name, 0, sizeof(data->model_name));
memset(data->fan_dir, 0, sizeof(data->fan_dir));
power_good = (data->status >> (3-data->index) & 0x1);
if (power_good) {
if (as7712_32x_psu_model_name_get(dev) < 0) {
goto exit;
}
if (strncmp(data->model_name,
models[PSU_TYPE_DC_12V].model_name,
models[PSU_TYPE_DC_12V].length) == 0) {
/* Read fan direction */
status = as7712_32x_psu_read_block(client, DC12V_FAN_DIR_OFFSET,
data->fan_dir, DC12V_FAN_DIR_LEN);
if (status < 0) {
data->fan_dir[0] = '\0';
dev_dbg(&client->dev, "unable to read fan direction from (0x%x) offset(0x%x)\n",
client->addr, DC12V_FAN_DIR_OFFSET);
goto exit;
}
}
}
data->last_updated = jiffies;
data->valid = 1;
}
exit:
mutex_unlock(&data->update_lock);
return data;
}
static int __init as7712_32x_psu_init(void)
{
extern int platform_accton_as7712_32x(void);
if (!platform_accton_as7712_32x()) {
return -ENODEV;
}
return i2c_add_driver(&as7712_32x_psu_driver);
}
static void __exit as7712_32x_psu_exit(void)
{
i2c_del_driver(&as7712_32x_psu_driver);
}
module_init(as7712_32x_psu_init);
module_exit(as7712_32x_psu_exit);
MODULE_AUTHOR("Brandon Chuang <brandon_chuang@accton.com.tw>");
MODULE_DESCRIPTION("as7712_32x_psu driver");
MODULE_LICENSE("GPL");

1
packages/platforms/accton/x86-64/as7712-32x/onlp/Makefile Normal file
View File

@@ -0,0 +1 @@
include $(ONL)/make/pkg.mk

1
packages/platforms/accton/x86-64/as7712-32x/onlp/PKG.yml Normal file
View File

@@ -0,0 +1 @@
!include $ONL_TEMPLATES/onlp-platform-any.yml PLATFORM=x86-64-accton-as7712-32x ARCH=amd64 TOOLCHAIN=x86_64-linux-gnu

2
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/Makefile Normal file
View File

@@ -0,0 +1,2 @@
FILTER=src
include $(ONL)/make/subdirs.mk

25
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/lib/Makefile Normal file
View File

@@ -0,0 +1,25 @@
############################################################
# <bsn.cl fy=2014 v=onl>
#
# 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.
#
# </bsn.cl>
############################################################
#
#
############################################################
PLATFORM := x86-64-accton-as7712-32x
include $(ONL)/packages/base/any/onlp/builds/platform/libonlp-platform.mk

22
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/onlps/Makefile Normal file
View File

@@ -0,0 +1,22 @@
############################################################
# <bsn.cl fy=2014 v=onl>
#
# 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.
#
# </bsn.cl>
############################################################
PLATFORM := x86-64-accton-as7712-32x
include $(ONL)/packages/base/any/onlp/builds/platform/onlps.mk

10
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/onlps/onlps.mk Normal file
View File

@@ -0,0 +1,10 @@
###############################################################################
#
# Inclusive Makefile for the onlps module.
#
# Autogenerated 2018-07-20 19:59:30.668776
#
###############################################################################
onlps_BASEDIR := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))

1
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
*.mk

1
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/.module Normal file
View File

@@ -0,0 +1 @@
name: x86_64_accton_as7712_32x

9
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/Makefile Normal file
View File

@@ -0,0 +1,9 @@
###############################################################################
#
#
#
###############################################################################
include $(ONL)/make/config.mk
MODULE := x86_64_accton_as7712_32x
AUTOMODULE := x86_64_accton_as7712_32x
include $(BUILDER)/definemodule.mk

6
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/README Normal file
View File

@@ -0,0 +1,6 @@
###############################################################################
#
# x86_64_accton_as7712_32x README
#
###############################################################################

9
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/auto/make.mk Normal file
View File

@@ -0,0 +1,9 @@
###############################################################################
#
# x86_64_accton_as7712_32x Autogeneration
#
###############################################################################
x86_64_accton_as7712_32x_AUTO_DEFS := module/auto/x86_64_accton_as7712_32x.yml
x86_64_accton_as7712_32x_AUTO_DIRS := module/inc/x86_64_accton_as7712_32x module/src
include $(BUILDER)/auto.mk

50
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/auto/x86_64_accton_as7712_32x.yml Normal file
View File

@@ -0,0 +1,50 @@
###############################################################################
#
# x86_64_accton_as7712_32x Autogeneration Definitions.
#
###############################################################################
cdefs: &cdefs
- X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_LOGGING:
doc: "Include or exclude logging."
default: 1
- X86_64_ACCTON_AS7712_32X_CONFIG_LOG_OPTIONS_DEFAULT:
doc: "Default enabled log options."
default: AIM_LOG_OPTIONS_DEFAULT
- X86_64_ACCTON_AS7712_32X_CONFIG_LOG_BITS_DEFAULT:
doc: "Default enabled log bits."
default: AIM_LOG_BITS_DEFAULT
- X86_64_ACCTON_AS7712_32X_CONFIG_LOG_CUSTOM_BITS_DEFAULT:
doc: "Default enabled custom log bits."
default: 0
- X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB:
doc: "Default all porting macros to use the C standard libraries."
default: 1
- X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS:
doc: "Include standard library headers for stdlib porting macros."
default: x86_64_accton_as7712_32x_CONFIG_PORTING_STDLIB
- X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_UCLI:
doc: "Include generic uCli support."
default: 0
- X86_64_ACCTON_AS7712_32X_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_as7712_32x_CONFIG_HEADER:
defs: *cdefs
basename: x86_64_accton_as7712_32x_config
portingmacro:
x86_64_accton_as7712_32x:
macros:
- malloc
- free
- memset
- memcpy
- strncpy
- vsnprintf
- snprintf
- strlen

14
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/inc/x86_64_accton_as7712_32x/x86_64_accton_as7712_32x.x Normal file
View File

@@ -0,0 +1,14 @@
/**************************************************************************//**
*
*
*
*****************************************************************************/
#include <x86_64_accton_as7712_32x/x86_64_accton_as7712_32x_config.h>
/* <--auto.start.xmacro(ALL).define> */
/* <auto.end.xmacro(ALL).define> */
/* <--auto.start.xenum(ALL).define> */
/* <auto.end.xenum(ALL).define> */

137
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/inc/x86_64_accton_as7712_32x/x86_64_accton_as7712_32x_config.h Normal file
View File

@@ -0,0 +1,137 @@
/**************************************************************************//**
*
* @file
* @brief x86_64_accton_as7712_32x Configuration Header
*
* @addtogroup x86_64_accton_as7712_32x-config
* @{
*
*****************************************************************************/
#ifndef __x86_64_accton_as7712_32x_CONFIG_H__
#define __x86_64_accton_as7712_32x_CONFIG_H__
#ifdef GLOBAL_INCLUDE_CUSTOM_CONFIG
#include <global_custom_config.h>
#endif
#ifdef x86_64_accton_as7712_32x_INCLUDE_CUSTOM_CONFIG
#include <x86_64_accton_as7712_32x_custom_config.h>
#endif
/* <auto.start.cdefs(x86_64_accton_as7712_32x_CONFIG_HEADER).header> */
#include <AIM/aim.h>
/**
* X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_LOGGING
*
* Include or exclude logging. */
#ifndef X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_LOGGING
#define X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_LOGGING 1
#endif
/**
* X86_64_ACCTON_AS7712_32X_CONFIG_LOG_OPTIONS_DEFAULT
*
* Default enabled log options. */
#ifndef X86_64_ACCTON_AS7712_32X_CONFIG_LOG_OPTIONS_DEFAULT
#define X86_64_ACCTON_AS7712_32X_CONFIG_LOG_OPTIONS_DEFAULT AIM_LOG_OPTIONS_DEFAULT
#endif
/**
* X86_64_ACCTON_AS7712_32X_CONFIG_LOG_BITS_DEFAULT
*
* Default enabled log bits. */
#ifndef X86_64_ACCTON_AS7712_32X_CONFIG_LOG_BITS_DEFAULT
#define X86_64_ACCTON_AS7712_32X_CONFIG_LOG_BITS_DEFAULT AIM_LOG_BITS_DEFAULT
#endif
/**
* X86_64_ACCTON_AS7712_32X_CONFIG_LOG_CUSTOM_BITS_DEFAULT
*
* Default enabled custom log bits. */
#ifndef X86_64_ACCTON_AS7712_32X_CONFIG_LOG_CUSTOM_BITS_DEFAULT
#define X86_64_ACCTON_AS7712_32X_CONFIG_LOG_CUSTOM_BITS_DEFAULT 0
#endif
/**
* X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB
*
* Default all porting macros to use the C standard libraries. */
#ifndef X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB
#define X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB 1
#endif
/**
* X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS
*
* Include standard library headers for stdlib porting macros. */
#ifndef X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS
#define X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS x86_64_accton_as7712_32x_CONFIG_PORTING_STDLIB
#endif
/**
* X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_UCLI
*
* Include generic uCli support. */
#ifndef X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_UCLI
#define X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_UCLI 0
#endif
/**
* X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION
*
* Assume chassis fan direction is the same as the PSU fan direction. */
#ifndef X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION
#define X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION 0
#endif
/**
* All compile time options can be queried or displayed
*/
/** Configuration settings structure. */
typedef struct x86_64_accton_as7712_32x_config_settings_s {
/** name */
const char* name;
/** value */
const char* value;
} x86_64_accton_as7712_32x_config_settings_t;
/** Configuration settings table. */
/** x86_64_accton_as7712_32x_config_settings table. */
extern x86_64_accton_as7712_32x_config_settings_t x86_64_accton_as7712_32x_config_settings[];
/**
* @brief Lookup a configuration setting.
* @param setting The name of the configuration option to lookup.
*/
const char* x86_64_accton_as7712_32x_config_lookup(const char* setting);
/**
* @brief Show the compile-time configuration.
* @param pvs The output stream.
*/
int x86_64_accton_as7712_32x_config_show(struct aim_pvs_s* pvs);
/* <auto.end.cdefs(x86_64_accton_as7712_32x_CONFIG_HEADER).header> */
#include "x86_64_accton_as7712_32x_porting.h"
#endif /* __x86_64_accton_as7712_32x_CONFIG_H__ */
/* @} */

26
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/inc/x86_64_accton_as7712_32x/x86_64_accton_as7712_32x_dox.h Normal file
View File

@@ -0,0 +1,26 @@
/**************************************************************************//**
*
* x86_64_accton_as7712_32x Doxygen Header
*
*****************************************************************************/
#ifndef __x86_64_accton_as7712_32x_DOX_H__
#define __x86_64_accton_as7712_32x_DOX_H__
/**
* @defgroup x86_64_accton_as7712_32x x86_64_accton_as7712_32x - x86_64_accton_as7712_32x Description
*
The documentation overview for this module should go here.
*
* @{
*
* @defgroup x86_64_accton_as7712_32x-x86_64_accton_as7712_32x Public Interface
* @defgroup x86_64_accton_as7712_32x-config Compile Time Configuration
* @defgroup x86_64_accton_as7712_32x-porting Porting Macros
*
* @}
*
*/
#endif /* __x86_64_accton_as7712_32x_DOX_H__ */

107
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/inc/x86_64_accton_as7712_32x/x86_64_accton_as7712_32x_porting.h Normal file
View File

@@ -0,0 +1,107 @@
/**************************************************************************//**
*
* @file
* @brief x86_64_accton_as7712_32x Porting Macros.
*
* @addtogroup x86_64_accton_as7712_32x-porting
* @{
*
*****************************************************************************/
#ifndef __x86_64_accton_as7712_32x_PORTING_H__
#define __x86_64_accton_as7712_32x_PORTING_H__
/* <auto.start.portingmacro(ALL).define> */
#if X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS == 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <memory.h>
#endif
#ifndef X86_64_ACCTON_AS7712_32X_MALLOC
#if defined(GLOBAL_MALLOC)
#define X86_64_ACCTON_AS7712_32X_MALLOC GLOBAL_MALLOC
#elif X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB == 1
#define X86_64_ACCTON_AS7712_32X_MALLOC malloc
#else
#error The macro X86_64_ACCTON_AS7712_32X_MALLOC is required but cannot be defined.
#endif
#endif
#ifndef X86_64_ACCTON_AS7712_32X_FREE
#if defined(GLOBAL_FREE)
#define X86_64_ACCTON_AS7712_32X_FREE GLOBAL_FREE
#elif X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB == 1
#define X86_64_ACCTON_AS7712_32X_FREE free
#else
#error The macro X86_64_ACCTON_AS7712_32X_FREE is required but cannot be defined.
#endif
#endif
#ifndef X86_64_ACCTON_AS7712_32X_MEMSET
#if defined(GLOBAL_MEMSET)
#define X86_64_ACCTON_AS7712_32X_MEMSET GLOBAL_MEMSET
#elif X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB == 1
#define X86_64_ACCTON_AS7712_32X_MEMSET memset
#else
#error The macro X86_64_ACCTON_AS7712_32X_MEMSET is required but cannot be defined.
#endif
#endif
#ifndef X86_64_ACCTON_AS7712_32X_MEMCPY
#if defined(GLOBAL_MEMCPY)
#define X86_64_ACCTON_AS7712_32X_MEMCPY GLOBAL_MEMCPY
#elif X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB == 1
#define X86_64_ACCTON_AS7712_32X_MEMCPY memcpy
#else
#error The macro X86_64_ACCTON_AS7712_32X_MEMCPY is required but cannot be defined.
#endif
#endif
#ifndef X86_64_ACCTON_AS7712_32X_STRNCPY
#if defined(GLOBAL_STRNCPY)
#define X86_64_ACCTON_AS7712_32X_STRNCPY GLOBAL_STRNCPY
#elif X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB == 1
#define X86_64_ACCTON_AS7712_32X_STRNCPY strncpy
#else
#error The macro X86_64_ACCTON_AS7712_32X_STRNCPY is required but cannot be defined.
#endif
#endif
#ifndef X86_64_ACCTON_AS7712_32X_VSNPRINTF
#if defined(GLOBAL_VSNPRINTF)
#define X86_64_ACCTON_AS7712_32X_VSNPRINTF GLOBAL_VSNPRINTF
#elif X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB == 1
#define X86_64_ACCTON_AS7712_32X_VSNPRINTF vsnprintf
#else
#error The macro X86_64_ACCTON_AS7712_32X_VSNPRINTF is required but cannot be defined.
#endif
#endif
#ifndef X86_64_ACCTON_AS7712_32X_SNPRINTF
#if defined(GLOBAL_SNPRINTF)
#define X86_64_ACCTON_AS7712_32X_SNPRINTF GLOBAL_SNPRINTF
#elif X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB == 1
#define X86_64_ACCTON_AS7712_32X_SNPRINTF snprintf
#else
#error The macro X86_64_ACCTON_AS7712_32X_SNPRINTF is required but cannot be defined.
#endif
#endif
#ifndef X86_64_ACCTON_AS7712_32X_STRLEN
#if defined(GLOBAL_STRLEN)
#define X86_64_ACCTON_AS7712_32X_STRLEN GLOBAL_STRLEN
#elif X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB == 1
#define X86_64_ACCTON_AS7712_32X_STRLEN strlen
#else
#error The macro X86_64_ACCTON_AS7712_32X_STRLEN is required but cannot be defined.
#endif
#endif
/* <auto.end.portingmacro(ALL).define> */
#endif /* __x86_64_accton_as7712_32x_PORTING_H__ */
/* @} */

10
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/make.mk Normal file
View File

@@ -0,0 +1,10 @@
###############################################################################
#
#
#
###############################################################################
THIS_DIR := $(dir $(lastword $(MAKEFILE_LIST)))
x86_64_accton_as7712_32x_INCLUDES := -I $(THIS_DIR)inc
x86_64_accton_as7712_32x_INTERNAL_INCLUDES := -I $(THIS_DIR)src
x86_64_accton_as7712_32x_DEPENDMODULE_ENTRIES := init:x86_64_accton_as7712_32x ucli:x86_64_accton_as7712_32x

9
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/Makefile Normal file
View File

@@ -0,0 +1,9 @@
###############################################################################
#
# Local source generation targets.
#
###############################################################################
ucli:
@../../../../tools/uclihandlers.py x86_64_accton_as7712_32x_ucli.c

44
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/attributei.c Normal file
View File

@@ -0,0 +1,44 @@
#include <onlp/platformi/attributei.h>
#include <onlp/stdattrs.h>
#include <onlplib/file.h>
#include "platform_lib.h"
int
onlp_attributei_onie_info_get(onlp_oid_t oid, onlp_onie_info_t* rp)
{
if(oid != ONLP_OID_CHASSIS) {
return ONLP_STATUS_E_UNSUPPORTED;
}
if(rp == NULL) {
return 1;
}
return onlp_onie_decode_file(rp, IDPROM_PATH);
}
int
onlp_attributei_asset_info_get(onlp_oid_t oid, onlp_asset_info_t* rp)
{
if(oid != ONLP_OID_CHASSIS) {
return ONLP_STATUS_E_UNSUPPORTED;
}
if(rp == NULL) {
return 1;
}
int rv;
int v[3] = {0};
rp->oid = oid;
if(ONLP_SUCCESS(rv = onlp_file_read_int(v, "/sys/bus/i2c/devices/4-0060/version")) &&
ONLP_SUCCESS(rv = onlp_file_read_int(v+1, "/sys/bus/i2c/devices/5-0062/version")) &&
ONLP_SUCCESS(rv = onlp_file_read_int(v+2, "/sys/bus/i2c/devices/6-0064/version"))) {
rp->firmware_revision =
aim_fstrdup("%d.%d.%d", v[0], v[1], v[2]);
}
return rv;
}

48
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/chassisi.c Normal file
View File

@@ -0,0 +1,48 @@
#include <onlp/platformi/chassisi.h>
#include "platform_lib.h"
int
onlp_chassisi_hdr_get(onlp_oid_id_t id, onlp_oid_hdr_t* hdr)
{
int i;
onlp_oid_t* e = hdr->coids;
ONLP_OID_STATUS_FLAG_SET(hdr, PRESENT);
ONLP_OID_STATUS_FLAG_SET(hdr, OPERATIONAL);
/* 4 Thermal sensors on the chassis */
for (i = 1; i <= NUM_OF_THERMAL_ON_MAIN_BOARD; i++)
{
*e++ = ONLP_THERMAL_ID_CREATE(i);
}
/* 5 LEDs on the chassis */
for (i = 1; i <= NUM_OF_LED_ON_MAIN_BOARD; i++)
{
*e++ = ONLP_LED_ID_CREATE(i);
}
/* 2 PSUs on the chassis */
for (i = 1; i <= NUM_OF_PSU_ON_MAIN_BOARD; i++)
{
*e++ = ONLP_PSU_ID_CREATE(i);
}
/* 4 Fans on the chassis */
for (i = 1; i <= NUM_OF_FAN_ON_MAIN_BOARD; i++)
{
*e++ = ONLP_FAN_ID_CREATE(i);
}
/* 32 SFPs */
for(i = 1; i <= 32; i++) {
*e++ = ONLP_SFP_ID_CREATE(i);
}
return 0;
}
int
onlp_chassisi_info_get(onlp_oid_id_t id, onlp_chassis_info_t* info)
{
return onlp_chassisi_hdr_get(id, &info->hdr);
}

350
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/fani.c Normal file
View File

@@ -0,0 +1,350 @@
/************************************************************
* <bsn.cl fy=2014 v=onl>
*
* 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.
*
* </bsn.cl>
************************************************************/
#include <onlp/platformi/base.h>
#include "platform_lib.h"
#define SYS_I2C_DEVICES "/sys/bus/i2c/devices"
#define SYSFS_FAN_DIR "/sys/bus/i2c/devices/2-0066"
#define PREFIX_PATH_ON_MAIN_BOARD "/sys/bus/i2c/devices/2-0066/"
#define PSU_SYSFS_DIR "/sys/bus/i2c/devices/"
#define MAX_FAN_SPEED 18000
#define MAX_PSU_FAN_SPEED 25500
#define PROJECT_NAME
#define LEN_FILE_NAME 80
#define FAN_RESERVED 0
#define FAN_1_ON_MAIN_BOARD 1
#define FAN_2_ON_MAIN_BOARD 2
#define FAN_3_ON_MAIN_BOARD 3
#define FAN_4_ON_MAIN_BOARD 4
#define FAN_5_ON_MAIN_BOARD 5
#define FAN_6_ON_MAIN_BOARD 6
#define FAN_1_ON_PSU1 7
#define FAN_1_ON_PSU2 8
typedef struct fan_path_S
{
char present[LEN_FILE_NAME];
char status[LEN_FILE_NAME];
char speed[LEN_FILE_NAME];
char direction[LEN_FILE_NAME];
char ctrl_speed[LEN_FILE_NAME];
char r_speed[LEN_FILE_NAME];
}fan_path_T;
#define _MAKE_FAN_PATH_ON_MAIN_BOARD(prj,id) \
{ \
.present = #prj"fan"#id"_present", \
.status = #prj"fan"#id"_fault", \
.speed = #prj"fan"#id"_front_speed_rpm", \
.direction = #prj"fan"#id"_direction", \
.ctrl_speed = #prj"fan_duty_cycle_percentage", \
.r_speed = #prj"fan"#id"_rear_speed_rpm", \
}
#define MAKE_FAN_PATH_ON_MAIN_BOARD(prj,id) _MAKE_FAN_PATH_ON_MAIN_BOARD(prj,id)
#define MAKE_FAN_PATH_ON_PSU(folder) \
{"", #folder"/psu_fan1_fault", #folder"/psu_fan1_speed_rpm", \
"", #folder"/psu_fan1_duty_cycle_percentage", "" }
static fan_path_T fan_path[] = /* must map with onlp_fan_id */
{
MAKE_FAN_PATH_ON_MAIN_BOARD(PROJECT_NAME, FAN_RESERVED),
MAKE_FAN_PATH_ON_MAIN_BOARD(PROJECT_NAME, FAN_1_ON_MAIN_BOARD),
MAKE_FAN_PATH_ON_MAIN_BOARD(PROJECT_NAME, FAN_2_ON_MAIN_BOARD),
MAKE_FAN_PATH_ON_MAIN_BOARD(PROJECT_NAME, FAN_3_ON_MAIN_BOARD),
MAKE_FAN_PATH_ON_MAIN_BOARD(PROJECT_NAME, FAN_4_ON_MAIN_BOARD),
MAKE_FAN_PATH_ON_MAIN_BOARD(PROJECT_NAME, FAN_5_ON_MAIN_BOARD),
MAKE_FAN_PATH_ON_MAIN_BOARD(PROJECT_NAME, FAN_6_ON_MAIN_BOARD),
MAKE_FAN_PATH_ON_PSU(11-005b),
MAKE_FAN_PATH_ON_PSU(10-0058)
};
#define MAKE_FAN_INFO_NODE_ON_MAIN_BOARD(_id) \
{ \
.hdr = { \
.id = ONLP_FAN_ID_CREATE(FAN_##_id##_ON_MAIN_BOARD), \
.description = "Chassis Fan "#_id, \
.poid = ONLP_OID_CHASSIS, \
}, \
.dir = ONLP_FAN_DIR_UNKNOWN, \
.caps = (ONLP_FAN_CAPS_GET_DIR | ONLP_FAN_CAPS_SET_PERCENTAGE | ONLP_FAN_CAPS_GET_RPM | ONLP_FAN_CAPS_GET_PERCENTAGE), \
}
#define MAKE_FAN_INFO_NODE_ON_PSU(psu_id, fan_id) \
{ \
.hdr = { \
.id = ONLP_FAN_ID_CREATE(FAN_##fan_id##_ON_PSU##psu_id), \
.description = "Chassis PSU-"#psu_id " Fan "#fan_id, \
.poid = ONLP_PSU_ID_CREATE(PSU##psu_id##_ID) \
}, \
.dir = ONLP_FAN_DIR_UNKNOWN, \
.caps = (ONLP_FAN_CAPS_GET_DIR | ONLP_FAN_CAPS_SET_PERCENTAGE | ONLP_FAN_CAPS_GET_RPM | ONLP_FAN_CAPS_GET_PERCENTAGE), \
}
/* Static fan information */
onlp_fan_info_t fan_info[] = {
{ }, /* Not used */
MAKE_FAN_INFO_NODE_ON_MAIN_BOARD(1),
MAKE_FAN_INFO_NODE_ON_MAIN_BOARD(2),
MAKE_FAN_INFO_NODE_ON_MAIN_BOARD(3),
MAKE_FAN_INFO_NODE_ON_MAIN_BOARD(4),
MAKE_FAN_INFO_NODE_ON_MAIN_BOARD(5),
MAKE_FAN_INFO_NODE_ON_MAIN_BOARD(6),
MAKE_FAN_INFO_NODE_ON_PSU(1,1),
MAKE_FAN_INFO_NODE_ON_PSU(2,1),
};
static int
chassis_fani_hdr_get__(int id, onlp_oid_hdr_t* hdr)
{
int v;
*hdr = fan_info[id].hdr;
ONLP_TRY(onlp_file_read_int(&v, "%s/fan%d_present",
SYSFS_FAN_DIR, id));
if(v) {
/* Fan is present */
ONLP_OID_STATUS_FLAG_SET(hdr, PRESENT);
ONLP_TRY(onlp_file_read_int(&v, "%s/fan%d_fault",
SYSFS_FAN_DIR, id));
if(v) {
/* Fan has failed. */
ONLP_OID_STATUS_FLAG_SET(hdr, FAILED);
}
}
return 0;
}
static int
chassis_fani_info_get__(int id, onlp_fan_info_t* info)
{
*info = fan_info[id];
ONLP_TRY(chassis_fani_hdr_get__(id, &info->hdr));
/*
* Get fan/fanr direction (both : the same)
*/
int v;
ONLP_TRY(onlp_file_read_int(&v, "%s/fan%d_direction",
SYSFS_FAN_DIR, id));
info->dir = (v) ? ONLP_FAN_DIR_F2B : ONLP_FAN_DIR_B2F;
/*
* Get fan speed (take the min from two speeds)
*/
ONLP_TRY(onlp_file_read_int(&info->rpm, "%s/fan%d_front_speed_rpm",
SYSFS_FAN_DIR, id));
ONLP_TRY(onlp_file_read_int(&v, "%s/fan%d_rear_speed_rpm",
SYSFS_FAN_DIR, id));
if(v < info->rpm) {
info->rpm = v;
}
/* get speed percentage from rpm */
info->percentage = (info->rpm * 100)/MAX_FAN_SPEED;
return ONLP_STATUS_OK;
}
static int
psu_fani_hdr_get__(int id, const char* device, onlp_oid_hdr_t* hdr)
{
int v;
int rv;
*hdr = fan_info[id].hdr;
if(ONLP_SUCCESS(rv = onlp_file_read_int(&v,
"%s/%s/psu_fan1_fault",
SYS_I2C_DEVICES,
device))) {
ONLP_OID_STATUS_FLAG_SET(hdr, PRESENT);
if(v) {
ONLP_OID_STATUS_FLAG_SET(hdr, FAILED);
}
}
return rv;
}
static int
psu_fani_info_get__(int id, const char* device, onlp_fan_info_t* info)
{
*info = fan_info[id];
ONLP_TRY(psu_fani_hdr_get__(id, device, &info->hdr));
if(ONLP_OID_STATUS_FLAG_NOT_SET(info, PRESENT) ||
ONLP_OID_STATUS_FLAG_IS_SET(info, FAILED)) {
return 0;
}
/*
* Direction.
*/
char* dir = NULL;
ONLP_TRY(onlp_file_read_str(&dir,
"%s/%s/psu_fan_dir",
SYS_I2C_DEVICES,
device));
if(dir) {
if(!strcmp(dir, "F2B\n")) {
info->dir = ONLP_FAN_DIR_F2B;
}
else if(!strcmp(dir, "B2F\n")) {
info->dir = ONLP_FAN_DIR_B2F;
}
else {
info->dir = ONLP_FAN_DIR_UNKNOWN;
}
aim_free(dir);
}
ONLP_TRY(onlp_file_read_int(&info->rpm, "%s/%s/psu_fan1_speed_rpm",
SYS_I2C_DEVICES, device));
info->percentage = (info->rpm * 100) / MAX_PSU_FAN_SPEED;
return ONLP_STATUS_OK;
}
int
onlp_fani_hdr_get(onlp_oid_t oid, onlp_oid_hdr_t* hdr)
{
int id = ONLP_OID_ID_GET(oid);
switch(id)
{
case FAN_1_ON_PSU1:
return psu_fani_hdr_get__(id, "11-005b", hdr);
case FAN_1_ON_PSU2:
return psu_fani_hdr_get__(id, "10-0058", hdr);
case FAN_1_ON_MAIN_BOARD:
case FAN_2_ON_MAIN_BOARD:
case FAN_3_ON_MAIN_BOARD:
case FAN_4_ON_MAIN_BOARD:
case FAN_5_ON_MAIN_BOARD:
case FAN_6_ON_MAIN_BOARD:
return chassis_fani_hdr_get__(id, hdr);
default:
return ONLP_STATUS_E_PARAM;
}
}
int
onlp_fani_info_get(onlp_oid_t oid, onlp_fan_info_t* info)
{
int id = ONLP_OID_ID_GET(oid);
switch(id)
{
case FAN_1_ON_PSU1:
return psu_fani_info_get__(id, "11-005b", info);
case FAN_1_ON_PSU2:
return psu_fani_info_get__(id, "10-0058", info);
case FAN_1_ON_MAIN_BOARD:
case FAN_2_ON_MAIN_BOARD:
case FAN_3_ON_MAIN_BOARD:
case FAN_4_ON_MAIN_BOARD:
case FAN_5_ON_MAIN_BOARD:
case FAN_6_ON_MAIN_BOARD:
return chassis_fani_info_get__(id, info);
default:
return ONLP_STATUS_E_PARAM;
}
}
/*
* 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 fd, len, nbytes=10, local_id;
char data[10] = {0};
char fullpath[70] = {0};
local_id = ONLP_OID_ID_GET(id);
/* reject p=0 (p=0, stop fan) */
if (p == 0){
return ONLP_STATUS_E_INVALID;
}
/* get fullpath */
switch (local_id)
{
case FAN_1_ON_PSU1:
case FAN_1_ON_PSU2:
sprintf(fullpath, "%s%s", SYS_I2C_DEVICES, fan_path[local_id].ctrl_speed);
break;
case FAN_1_ON_MAIN_BOARD:
case FAN_2_ON_MAIN_BOARD:
case FAN_3_ON_MAIN_BOARD:
case FAN_4_ON_MAIN_BOARD:
case FAN_5_ON_MAIN_BOARD:
case FAN_6_ON_MAIN_BOARD:
sprintf(fullpath, "%s%s", PREFIX_PATH_ON_MAIN_BOARD, fan_path[local_id].ctrl_speed);
break;
default:
return ONLP_STATUS_E_INVALID;
}
sprintf(data, "%d", p);
/* Create output file descriptor */
fd = open(fullpath, O_WRONLY, 0644);
if (fd == -1){
return ONLP_STATUS_E_INTERNAL;
}
len = write (fd, data, (ssize_t) nbytes);
if (len != nbytes) {
close(fd);
return ONLP_STATUS_E_INTERNAL;
}
close(fd);
return ONLP_STATUS_OK;
}

203
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/ledi.c Normal file
View File

@@ -0,0 +1,203 @@
/************************************************************
* <bsn.cl fy=2014 v=onl>
*
* 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.
*
* </bsn.cl>
************************************************************
*
*
*
***********************************************************/
#include <onlp/platformi/base.h>
#include "platform_lib.h"
#define prefix_path "/sys/class/leds/accton_as7712_32x_led::"
#define filename "brightness"
/* 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), "Chassis LED 1 (DIAG LED)", ONLP_OID_CHASSIS,
.status = ONLP_OID_STATUS_FLAG_PRESENT },
ONLP_LED_CAPS_OFF | ONLP_LED_CAPS_GREEN | ONLP_LED_CAPS_RED | ONLP_LED_CAPS_ORANGE,
},
{
{ ONLP_LED_ID_CREATE(LED_LOC), "Chassis LED 2 (LOC LED)", ONLP_OID_CHASSIS,
.status = ONLP_OID_STATUS_FLAG_PRESENT },
ONLP_LED_CAPS_OFF | ONLP_LED_CAPS_BLUE,
},
{
{ ONLP_LED_ID_CREATE(LED_FAN), "Chassis LED 3 (FAN LED)", ONLP_OID_CHASSIS,
.status = ONLP_OID_STATUS_FLAG_PRESENT},
ONLP_LED_CAPS_AUTO,
},
{
{ ONLP_LED_ID_CREATE(LED_PSU1), "Chassis LED 4 (PSU1 LED)", ONLP_OID_CHASSIS,
.status = ONLP_OID_STATUS_FLAG_PRESENT},
ONLP_LED_CAPS_AUTO,
},
{
{ ONLP_LED_ID_CREATE(LED_PSU2), "Chassis LED 4 (PSU2 LED)", ONLP_OID_CHASSIS,
.status = ONLP_OID_STATUS_FLAG_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;
}
int
onlp_ledi_hdr_get(onlp_oid_t oid, onlp_oid_hdr_t* hdr)
{
*hdr = linfo[ONLP_OID_ID_GET(oid)].hdr;
return 0;
}
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};
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 (deviceNodeReadString(fullpath, data, sizeof(data), 0) != 0) {
return ONLP_STATUS_E_INTERNAL;
}
info->mode = driver_to_onlp_led_mode(local_id, atoi(data));
return ONLP_STATUS_OK;
}
/*
* 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};
local_id = ONLP_OID_ID_GET(id);
sprintf(fullpath, "%s%s/%s", prefix_path, last_path[local_id], filename);
if (deviceNodeWriteInt(fullpath, onlp_to_driver_led_mode(local_id, mode), 0) != 0)
{
return ONLP_STATUS_E_INTERNAL;
}
return ONLP_STATUS_OK;
}

9
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/make.mk Normal file
View File

@@ -0,0 +1,9 @@
###############################################################################
#
#
#
###############################################################################
LIBRARY := x86_64_accton_as7712_32x
$(LIBRARY)_SUBDIR := $(dir $(lastword $(MAKEFILE_LIST)))
include $(BUILDER)/lib.mk

227
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/platform_lib.c Normal file
View File

@@ -0,0 +1,227 @@
/************************************************************
* <bsn.cl fy=2014 v=onl>
*
* 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.
*
* </bsn.cl>
************************************************************
*
*
*
***********************************************************/
#include <onlp/onlp.h>
#include <onlplib/file.h>
#include <sys/mman.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <AIM/aim.h>
#include "platform_lib.h"
int deviceNodeWrite(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 deviceNodeWriteInt(char *filename, int value, int data_len)
{
char buf[8] = {0};
sprintf(buf, "%d", value);
return deviceNodeWrite(filename, buf, (int)strlen(buf), data_len);
}
int deviceNodeReadBinary(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 deviceNodeReadString(char *filename, char *buffer, int buf_size, int data_len)
{
int ret;
if (data_len >= buf_size) {
return -1;
}
ret = deviceNodeReadBinary(filename, buffer, buf_size-1, data_len);
if (ret == 0) {
buffer[buf_size-1] = '\0';
}
return ret;
}
#define I2C_PSU_MODEL_NAME_LEN 11
#define I2C_PSU_FAN_DIR_LEN 3
#include <ctype.h>
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 (deviceNodeReadString(node, model_name, sizeof(model_name), 0) != 0) {
return PSU_TYPE_UNKNOWN;
}
if(isspace(model_name[strlen(model_name)-1])) {
model_name[strlen(model_name)-1] = 0;
}
if (strncmp(model_name, "YM-2651Y", 8) == 0) {
if (modelname) {
strncpy(modelname, model_name, 8);
}
node = (id == PSU1_ID) ? PSU1_AC_PMBUS_NODE(psu_fan_dir) : PSU2_AC_PMBUS_NODE(psu_fan_dir);
if (deviceNodeReadString(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;
}
}
if (strncmp(model_name, "YM-2651V", 8) == 0) {
if (modelname) {
strncpy(modelname, model_name, 8);
}
node = (id == PSU1_ID) ? PSU1_AC_PMBUS_NODE(psu_fan_dir) : PSU2_AC_PMBUS_NODE(psu_fan_dir);
if (deviceNodeReadString(node, fan_dir, sizeof(fan_dir), 0) != 0) {
return PSU_TYPE_UNKNOWN;
}
if (strncmp(fan_dir, "F2B", strlen("F2B")) == 0) {
return PSU_TYPE_DC_48V_F2B;
}
if (strncmp(fan_dir, "B2F", strlen("B2F")) == 0) {
return PSU_TYPE_DC_48V_B2F;
}
}
if (strncmp(model_name, "PSU-12V-750", 11) == 0) {
if (modelname) {
strncpy(modelname, model_name, 11);
}
node = (id == PSU1_ID) ? PSU1_AC_HWMON_NODE(psu_fan_dir) : PSU2_AC_HWMON_NODE(psu_fan_dir);
if (deviceNodeReadString(node, fan_dir, sizeof(fan_dir), 0) != 0) {
return PSU_TYPE_UNKNOWN;
}
if (strncmp(fan_dir, "F2B", 3) == 0) {
return PSU_TYPE_DC_12V_F2B;
}
if (strncmp(fan_dir, "B2F", 3) == 0) {
return PSU_TYPE_DC_12V_B2F;
}
if (strncmp(fan_dir, "NON", 3) == 0) {
return PSU_TYPE_DC_12V_FANLESS;
}
}
return PSU_TYPE_UNKNOWN;
}
#define PSU_SERIAL_NUMBER_LEN 18
int psu_serial_number_get(int id, char *serial, int serial_len)
{
int size = 0;
int ret = ONLP_STATUS_OK;
char *prefix = NULL;
if (serial == NULL || serial_len < PSU_SERIAL_NUMBER_LEN) {
return ONLP_STATUS_E_PARAM;
}
prefix = (id == PSU1_ID) ? PSU1_AC_PMBUS_PREFIX : PSU2_AC_PMBUS_PREFIX;
ret = onlp_file_read((uint8_t*)serial, PSU_SERIAL_NUMBER_LEN, &size, "%s%s", prefix, "psu_mfr_serial");
if (ret != ONLP_STATUS_OK || size != PSU_SERIAL_NUMBER_LEN) {
return ONLP_STATUS_E_INTERNAL;
}
serial[PSU_SERIAL_NUMBER_LEN] = '\0';
return ONLP_STATUS_OK;
}

76
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/platform_lib.h Normal file
View File

@@ -0,0 +1,76 @@
/************************************************************
* <bsn.cl fy=2014 v=onl>
*
* 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.
*
* </bsn.cl>
************************************************************
*
*
*
***********************************************************/
#ifndef __PLATFORM_LIB_H__
#define __PLATFORM_LIB_H__
#include "x86_64_accton_as7712_32x_log.h"
#define CHASSIS_FAN_COUNT 6
#define CHASSIS_THERMAL_COUNT 5
#define NUM_OF_THERMAL_ON_MAIN_BOARD CHASSIS_THERMAL_COUNT
#define NUM_OF_FAN_ON_MAIN_BOARD CHASSIS_FAN_COUNT
#define NUM_OF_PSU_ON_MAIN_BOARD 2
#define NUM_OF_LED_ON_MAIN_BOARD 5
#define PSU1_ID 1
#define PSU2_ID 2
#define PSU1_AC_PMBUS_PREFIX "/sys/bus/i2c/devices/11-005b/"
#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-0053/"
#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 IDPROM_PATH "/sys/class/i2c-adapter/i2c-1/1-0057/eeprom"
int deviceNodeWriteInt(char *filename, int value, int data_len);
int deviceNodeReadBinary(char *filename, char *buffer, int buf_size, int data_len);
int deviceNodeReadString(char *filename, char *buffer, int buf_size, int data_len);
typedef enum psu_type {
PSU_TYPE_UNKNOWN,
PSU_TYPE_OK,
PSU_TYPE_AC_F2B,
PSU_TYPE_AC_B2F,
PSU_TYPE_DC_48V_F2B,
PSU_TYPE_DC_48V_B2F,
PSU_TYPE_DC_12V_FANLESS,
PSU_TYPE_DC_12V_F2B,
PSU_TYPE_DC_12V_B2F
} psu_type_t;
psu_type_t get_psu_type(int id, char* modelname, int modelname_len);
int psu_serial_number_get(int id, char *serial, int serial_len);
#endif /* __PLATFORM_LIB_H__ */

207
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/platformi.c Normal file
View File

@@ -0,0 +1,207 @@
/************************************************************
* <bsn.cl fy=2014 v=onl>
*
* 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.
*
* </bsn.cl>
************************************************************
*
*
*
***********************************************************/
#include <onlp/platformi/base.h>
#include "platform_lib.h"
#include "x86_64_accton_as7712_32x_int.h"
#include "x86_64_accton_as7712_32x_log.h"
const char*
onlp_platformi_get(void)
{
return "x86-64-accton-as7712-32x-r0";
}
int
onlp_platformi_sw_init(void)
{
return 0;
}
typedef struct fan_ctrl_policy {
int duty_cycle;
int temp_down_adjust; /* The boundary temperature to down adjust fan speed */
int temp_up_adjust; /* The boundary temperature to up adjust fan speed */
} fan_ctrl_policy_t;
fan_ctrl_policy_t fan_ctrl_policy_f2b[] = {
{32, 0, 174000},
{38, 170000, 182000},
{50, 178000, 190000},
{63, 186000, 0}
};
fan_ctrl_policy_t fan_ctrl_policy_b2f[] = {
{32, 0, 140000},
{38, 135000, 150000},
{50, 145000, 160000},
{69, 155000, 0}
};
#define FAN_DUTY_CYCLE_MAX 100
#define FAN_SPEED_CTRL_PATH "/sys/bus/i2c/devices/2-0066/fan_duty_cycle_percentage"
/*
* For AC power Front to Back :
* * If any fan fail, please fan speed register to 15
* * The max value of Fan speed register is 9
* [LM75(48) + LM75(49) + LM75(4A)] > 174 => set Fan speed value from 4 to 5
* [LM75(48) + LM75(49) + LM75(4A)] > 182 => set Fan speed value from 5 to 7
* [LM75(48) + LM75(49) + LM75(4A)] > 190 => set Fan speed value from 7 to 9
*
* [LM75(48) + LM75(49) + LM75(4A)] < 170 => set Fan speed value from 5 to 4
* [LM75(48) + LM75(49) + LM75(4A)] < 178 => set Fan speed value from 7 to 5
* [LM75(48) + LM75(49) + LM75(4A)] < 186 => set Fan speed value from 9 to 7
*
*
* For AC power Back to Front :
* * If any fan fail, please fan speed register to 15
* * The max value of Fan speed register is 10
* [LM75(48) + LM75(49) + LM75(4A)] > 140 => set Fan speed value from 4 to 5
* [LM75(48) + LM75(49) + LM75(4A)] > 150 => set Fan speed value from 5 to 7
* [LM75(48) + LM75(49) + LM75(4A)] > 160 => set Fan speed value from 7 to 10
*
* [LM75(48) + LM75(49) + LM75(4A)] < 135 => set Fan speed value from 5 to 4
* [LM75(48) + LM75(49) + LM75(4A)] < 145 => set Fan speed value from 7 to 5
* [LM75(48) + LM75(49) + LM75(4A)] < 155 => set Fan speed value from 10 to 7
*/
int
onlp_platformi_manage_fans(void)
{
int i = 0, arr_size, temp;
fan_ctrl_policy_t *policy;
int cur_duty_cycle, new_duty_cycle;
onlp_thermal_info_t thermal_1, thermal_2, thermal_3;
int fd, len;
char buf[10] = {0};
/* Get each fan status
*/
for (i = 1; i <= NUM_OF_FAN_ON_MAIN_BOARD; 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;
}
/* Decision 1: Set fan as full speed if any fan is failed.
*/
if(ONLP_OID_STATUS_FLAG_IS_SET(&fan_info, FAILED)) {
AIM_LOG_ERROR("Fan(%d) is not working, set the other fans as full speed\r\n", i);
return onlp_fani_percentage_set(ONLP_FAN_ID_CREATE(1), FAN_DUTY_CYCLE_MAX);
}
/* Decision 1.1: Set fan as full speed if any fan is not present.
*/
if(ONLP_OID_STATUS_FLAG_NOT_SET(&fan_info, PRESENT)) {
AIM_LOG_ERROR("Fan(%d) is not present, set the other fans as full speed\r\n", i);
return onlp_fani_percentage_set(ONLP_FAN_ID_CREATE(1), FAN_DUTY_CYCLE_MAX);
}
/* Get fan direction (Only get the first one since all fan direction are the same)
*/
if (i == 1) {
if(fan_info.dir == ONLP_FAN_DIR_F2B) {
policy = fan_ctrl_policy_f2b;
arr_size = AIM_ARRAYSIZE(fan_ctrl_policy_f2b);
}
else {
policy = fan_ctrl_policy_b2f;
arr_size = AIM_ARRAYSIZE(fan_ctrl_policy_b2f);
}
}
}
/* Get current fan speed
*/
fd = open(FAN_SPEED_CTRL_PATH, O_RDONLY);
if (fd == -1){
AIM_LOG_ERROR("Unable to open fan speed control node (%s)", FAN_SPEED_CTRL_PATH);
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)", FAN_SPEED_CTRL_PATH);
return ONLP_STATUS_E_INTERNAL;
}
cur_duty_cycle = atoi(buf);
/* Decision 2: If no matched fan speed is found from the policy,
* use FAN_DUTY_CYCLE_MIN as default speed
*/
for (i = 0; i < arr_size; i++) {
if (policy[i].duty_cycle != cur_duty_cycle)
continue;
break;
}
if (i == arr_size) {
return onlp_fani_percentage_set(ONLP_FAN_ID_CREATE(1), policy[0].duty_cycle);
}
/* Get current temperature
*/
if (onlp_thermali_info_get(ONLP_THERMAL_ID_CREATE(2), &thermal_1) != ONLP_STATUS_OK ||
onlp_thermali_info_get(ONLP_THERMAL_ID_CREATE(3), &thermal_2) != ONLP_STATUS_OK ||
onlp_thermali_info_get(ONLP_THERMAL_ID_CREATE(4), &thermal_3) != ONLP_STATUS_OK) {
AIM_LOG_ERROR("Unable to read thermal status");
return ONLP_STATUS_E_INTERNAL;
}
temp = thermal_1.mcelsius + thermal_2.mcelsius + thermal_3.mcelsius;
/* Decision 3: Decide new fan speed depend on fan direction/current fan speed/temperature
*/
new_duty_cycle = cur_duty_cycle;
if ((temp >= policy[i].temp_up_adjust) && (i != (arr_size-1))) {
new_duty_cycle = policy[i+1].duty_cycle;
}
else if ((temp <= policy[i].temp_down_adjust) && (i != 0)) {
new_duty_cycle = policy[i-1].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(ONLP_FAN_ID_CREATE(1), new_duty_cycle);
}
int
onlp_platformi_manage_leds(void)
{
return ONLP_STATUS_E_UNSUPPORTED;
}

258
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/psui.c Normal file
View File

@@ -0,0 +1,258 @@
/************************************************************
* <bsn.cl fy=2014 v=onl>
*
* 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.
*
* </bsn.cl>
************************************************************
*
*
*
***********************************************************/
#include <onlp/platformi/base.h>
#include "platform_lib.h"
#define PSU_STATUS_PRESENT 1
#define PSU_STATUS_POWER_GOOD 1
#define PSU_NODE_MAX_INT_LEN 8
#define PSU_NODE_MAX_PATH_LEN 64
static int
psu_status_info_get(int id, char *node, int *value)
{
int ret = 0;
char buf[PSU_NODE_MAX_INT_LEN + 1] = {0};
char node_path[PSU_NODE_MAX_PATH_LEN] = {0};
*value = 0;
if (PSU1_ID == id) {
sprintf(node_path, "%s%s", PSU1_AC_HWMON_PREFIX, node);
}
else if (PSU2_ID == id) {
sprintf(node_path, "%s%s", PSU2_AC_HWMON_PREFIX, node);
}
ret = deviceNodeReadString(node_path, buf, sizeof(buf), 0);
if (ret == 0) {
*value = atoi(buf);
}
return ret;
}
static int
psu_ym2651_pmbus_info_get(int id, char *node, int *value)
{
int ret = 0;
char buf[PSU_NODE_MAX_INT_LEN + 1] = {0};
char node_path[PSU_NODE_MAX_PATH_LEN] = {0};
*value = 0;
if (PSU1_ID == id) {
sprintf(node_path, "%s%s", PSU1_AC_PMBUS_PREFIX, node);
}
else {
sprintf(node_path, "%s%s", PSU2_AC_PMBUS_PREFIX, node);
}
ret = deviceNodeReadString(node_path, buf, sizeof(buf), 0);
if (ret == 0) {
*value = atoi(buf);
}
return ret;
}
static int
psu_ym2651_info_get(onlp_psu_info_t* info)
{
int val = 0;
int index = ONLP_OID_ID_GET(info->hdr.id);
if (ONLP_OID_STATUS_FLAG_IS_SET(info, FAILED)) {
return ONLP_STATUS_OK;
}
/* 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);
/* Read voltage, current and power */
if (psu_ym2651_pmbus_info_get(index, "psu_v_out", &val) == 0) {
info->mvout = val;
info->caps |= ONLP_PSU_CAPS_GET_VOUT;
}
if (psu_ym2651_pmbus_info_get(index, "psu_i_out", &val) == 0) {
info->miout = val;
info->caps |= ONLP_PSU_CAPS_GET_IOUT;
}
if (psu_ym2651_pmbus_info_get(index, "psu_p_out", &val) == 0) {
info->mpout = val;
info->caps |= ONLP_PSU_CAPS_GET_POUT;
}
psu_serial_number_get(index, info->serial, sizeof(info->serial));
return ONLP_STATUS_OK;
}
#include <onlplib/i2c.h>
#define DC12V_750_REG_TO_CURRENT(low, high) (((low << 4 | high >> 4) * 20 * 1000) / 754)
#define DC12V_750_REG_TO_VOLTAGE(low, high) ((low << 4 | high >> 4) * 25)
static int
psu_dc12v_750_info_get(onlp_psu_info_t* info)
{
int pid = ONLP_OID_ID_GET(info->hdr.id);
int bus = (PSU1_ID == pid) ? 11 : 10;
int iout_low, iout_high;
int vout_low, vout_high;
/* Set capability
*/
info->caps = ONLP_PSU_CAPS_GET_TYPE;
info->type = ONLP_PSU_TYPE_DC12;
if (ONLP_OID_STATUS_FLAG_IS_SET(info, FAILED)) {
return ONLP_STATUS_OK;
}
/* Get current
*/
iout_low = onlp_i2c_readb(bus, 0x6f, 0x0, ONLP_I2C_F_FORCE);
iout_high = onlp_i2c_readb(bus, 0x6f, 0x1, ONLP_I2C_F_FORCE);
if ((iout_low >= 0) && (iout_high >= 0)) {
info->miout = DC12V_750_REG_TO_CURRENT(iout_low, iout_high);
info->caps |= ONLP_PSU_CAPS_GET_IOUT;
}
/* Get voltage
*/
vout_low = onlp_i2c_readb(bus, 0x6f, 0x2, ONLP_I2C_F_FORCE);
vout_high = onlp_i2c_readb(bus, 0x6f, 0x3, ONLP_I2C_F_FORCE);
if ((vout_low >= 0) && (vout_high >= 0)) {
info->mvout = DC12V_750_REG_TO_VOLTAGE(vout_low, vout_high);
info->caps |= ONLP_PSU_CAPS_GET_VOUT;
}
/* Get power based on current and voltage
*/
if ((info->caps & ONLP_PSU_CAPS_GET_IOUT) && (info->caps & ONLP_PSU_CAPS_GET_VOUT)) {
info->mpout = (info->miout * info->mvout) / 1000;
info->caps |= ONLP_PSU_CAPS_GET_POUT;
}
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", ONLP_OID_CHASSIS },
},
{
{ ONLP_PSU_ID_CREATE(PSU2_ID), "PSU-2", ONLP_OID_CHASSIS },
}
};
int
onlp_psui_hdr_get(onlp_oid_t id, onlp_oid_hdr_t* hdr)
{
onlp_psu_info_t info;
ONLP_TRY(onlp_psui_info_get(id, &info));
*hdr = info.hdr;
return 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;
*info = pinfo[index]; /* Set the onlp_oid_hdr_t */
/* Get the present state */
if (psu_status_info_get(index, "psu_present", &val) != 0) {
printf("Unable to read PSU(%d) node(psu_present)\r\n", index);
}
if (val != PSU_STATUS_PRESENT) {
ONLP_OID_STATUS_FLAG_CLR(info, PRESENT);
return ONLP_STATUS_OK;
}
ONLP_OID_STATUS_FLAG_SET(info, PRESENT);
/* Get power good status */
if (psu_status_info_get(index, "psu_power_good", &val) != 0) {
printf("Unable to read PSU(%d) node(psu_power_good)\r\n", index);
}
if (val != PSU_STATUS_POWER_GOOD) {
ONLP_OID_STATUS_FLAG_SET(info, FAILED);
}
/* Get PSU type
*/
psu_type = get_psu_type(index, info->model, sizeof(info->model));
switch (psu_type) {
case PSU_TYPE_AC_F2B:
case PSU_TYPE_AC_B2F:
info->caps = ONLP_PSU_CAPS_GET_TYPE;
info->type = ONLP_PSU_TYPE_AC;
ret = psu_ym2651_info_get(info);
break;
case PSU_TYPE_DC_48V_F2B:
case PSU_TYPE_DC_48V_B2F:
info->caps = ONLP_PSU_CAPS_GET_TYPE;
info->type = ONLP_PSU_TYPE_DC48;
ret = psu_ym2651_info_get(info);
break;
case PSU_TYPE_DC_12V_F2B:
case PSU_TYPE_DC_12V_B2F:
case PSU_TYPE_DC_12V_FANLESS:
ret = psu_dc12v_750_info_get(info);
break;
case PSU_TYPE_UNKNOWN: /* User insert a unknown PSU or unplugged.*/
ONLP_OID_STATUS_FLAG_SET(info, UNPLUGGED);
ONLP_OID_STATUS_FLAG_CLR(info, FAILED);
ret = ONLP_STATUS_OK;
break;
default:
ret = ONLP_STATUS_E_UNSUPPORTED;
break;
}
return ret;
}

162
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/sfpi.c Normal file
View File

@@ -0,0 +1,162 @@
/************************************************************
* <bsn.cl fy=2014 v=onl>
*
* 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.
*
* </bsn.cl>
************************************************************
*
*
*
***********************************************************/
#include <onlp/platformi/base.h>
#include "platform_lib.h"
#define MUX_START_INDEX 18
#define NUM_OF_SFP_PORT 32
static const onlp_oid_id_t port_bus_index[NUM_OF_SFP_PORT] = {
4, 5, 6, 7, 9, 8, 11, 10,
0, 1, 2, 3, 12, 13, 14, 15,
16, 17, 18, 19, 28, 29, 30, 31,
20, 21, 22, 23, 24, 25, 26, 27
};
#define PORT_BUS_INDEX(port) (port_bus_index[port]+MUX_START_INDEX)
#define PORT_FORMAT "/sys/bus/i2c/devices/%d-0050/%s"
#define MODULE_PRESENT_FORMAT "/sys/bus/i2c/devices/4-0060/module_present_%d"
#define MODULE_PRESENT_ALL_ATTR "/sys/bus/i2c/devices/4-0060/module_present_all"
int
onlp_sfpi_type_get(onlp_oid_id_t port, onlp_sfp_type_t* rtype)
{
*rtype = ONLP_SFP_TYPE_QSFP28;
return 0;
}
int
onlp_sfpi_bitmap_get(onlp_sfp_bitmap_t* bmap)
{
/*
* Ports {0, 32}
*/
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(onlp_oid_id_t port)
{
/*
* Return 1 if present.
* Return 0 if not present.
* Return < 0 if error.
*/
int present;
if (onlp_file_read_int(&present, MODULE_PRESENT_FORMAT, (port+1)) < 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[4];
FILE* fp;
fp = fopen(MODULE_PRESENT_ALL_ATTR, "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",
bytes+0,
bytes+1,
bytes+2,
bytes+3
);
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;
}
/* Convert to 64 bit integer in port order */
int i = 0;
uint32_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_dev_read(onlp_oid_id_t port, int devaddr, int addr,
uint8_t* dst, int size)
{
int bus = PORT_BUS_INDEX(port);
return onlp_i2c_block_read(bus, devaddr, addr, size, dst, ONLP_I2C_F_FORCE);
}
int
onlp_sfpi_dev_readb(onlp_oid_id_t port, int devaddr, int addr)
{
int bus = PORT_BUS_INDEX(port);
return onlp_i2c_readb(bus, devaddr, addr, ONLP_I2C_F_FORCE);
}
int
onlp_sfpi_dev_writeb(onlp_oid_id_t port, int devaddr, int addr, uint8_t value)
{
int bus = PORT_BUS_INDEX(port);
return onlp_i2c_writeb(bus, devaddr, addr, value, ONLP_I2C_F_FORCE);
}
int
onlp_sfpi_dev_readw(onlp_oid_id_t port, int devaddr, int addr)
{
int bus = PORT_BUS_INDEX(port);
return onlp_i2c_readw(bus, devaddr, addr, ONLP_I2C_F_FORCE);
}
int
onlp_sfpi_dev_writew(onlp_oid_id_t port, int devaddr, int addr, uint16_t value)
{
int bus = PORT_BUS_INDEX(port);
return onlp_i2c_writew(bus, devaddr, addr, value, ONLP_I2C_F_FORCE);
}

91
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/thermali.c Normal file
View File

@@ -0,0 +1,91 @@
/************************************************************
* <bsn.cl fy=2014 v=onl>
*
* 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.
*
* </bsn.cl>
************************************************************
*
* Thermal Sensor Platform Implementation.
*
***********************************************************/
#include <onlp/platformi/base.h>
#include "platform_lib.h"
enum onlp_thermal_id
{
THERMAL_RESERVED = 0,
THERMAL_CPU_CORE,
THERMAL_1_ON_MAIN_BOARD,
THERMAL_2_ON_MAIN_BOARD,
THERMAL_3_ON_MAIN_BOARD,
THERMAL_4_ON_MAIN_BOARD,
THERMAL_1_ON_PSU1,
THERMAL_1_ON_PSU2,
};
static char* devfiles__[] = /* must map with onlp_thermal_id */
{
"reserved",
NULL, /* CPU_CORE files */
"/sys/bus/i2c/devices/3-0048*temp1_input",
"/sys/bus/i2c/devices/3-0049*temp1_input",
"/sys/bus/i2c/devices/3-004a*temp1_input",
"/sys/bus/i2c/devices/3-004b*temp1_input",
"/sys/bus/i2c/devices/11-005b*psu_temp1_input",
"/sys/bus/i2c/devices/10-0058*psu_temp1_input",
};
static char* cpu_coretemp_files[] =
{
"/sys/devices/platform/coretemp.0*temp2_input",
"/sys/devices/platform/coretemp.0*temp3_input",
"/sys/devices/platform/coretemp.0*temp4_input",
"/sys/devices/platform/coretemp.0*temp5_input",
NULL,
};
/* Static values */
static onlp_thermal_info_t thermal_info_table__[] = {
{ }, /* Not used */
ONLP_CHASSIS_THERMAL_INFO_ENTRY_INIT(THERMAL_CPU_CORE, "CPU Core"),
ONLP_CHASSIS_THERMAL_INFO_ENTRY_INIT(THERMAL_1_ON_MAIN_BOARD, "Chassis Thermal Sensor 1"),
ONLP_CHASSIS_THERMAL_INFO_ENTRY_INIT(THERMAL_2_ON_MAIN_BOARD, "Chassis Thermal Sensor 2"),
ONLP_CHASSIS_THERMAL_INFO_ENTRY_INIT(THERMAL_3_ON_MAIN_BOARD, "Chassis Thermal Sensor 3"),
ONLP_CHASSIS_THERMAL_INFO_ENTRY_INIT(THERMAL_4_ON_MAIN_BOARD, "Chassis Thermal Sensor 4"),
ONLP_PSU_THERMAL_INFO_ENTRY_INIT(THERMAL_1_ON_PSU1, "PSU-1 Thermal Sensor 1", PSU1_ID),
ONLP_PSU_THERMAL_INFO_ENTRY_INIT(THERMAL_1_ON_PSU2, "PSU-2 Thermal Sensor 1", PSU2_ID),
};
int
onlp_thermali_info_get(onlp_oid_id_t id, onlp_thermal_info_t* info)
{
ONLP_OID_INFO_ASSIGN(id, thermal_info_table__, info);
if(id == THERMAL_CPU_CORE) {
return onlp_file_read_int_max(&info->mcelsius, cpu_coretemp_files);
}
else {
return onlp_file_read_int(&info->mcelsius, devfiles__[id]);
}
}
int
onlp_thermali_hdr_get(onlp_oid_id_t id, onlp_oid_hdr_t* hdr)
{
*hdr = thermal_info_table__[id].hdr;
return 0;
}

81
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/x86_64_accton_as7712_32x_config.c Normal file
View File

@@ -0,0 +1,81 @@
/**************************************************************************//**
*
*
*
*****************************************************************************/
#include <x86_64_accton_as7712_32x/x86_64_accton_as7712_32x_config.h>
/* <auto.start.cdefs(x86_64_accton_as7712_32x_CONFIG_HEADER).source> */
#define __x86_64_accton_as7712_32x_config_STRINGIFY_NAME(_x) #_x
#define __x86_64_accton_as7712_32x_config_STRINGIFY_VALUE(_x) __x86_64_accton_as7712_32x_config_STRINGIFY_NAME(_x)
x86_64_accton_as7712_32x_config_settings_t x86_64_accton_as7712_32x_config_settings[] =
{
#ifdef X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_LOGGING
{ __x86_64_accton_as7712_32x_config_STRINGIFY_NAME(X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_LOGGING), __x86_64_accton_as7712_32x_config_STRINGIFY_VALUE(X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_LOGGING) },
#else
{ X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_LOGGING(__x86_64_accton_as7712_32x_config_STRINGIFY_NAME), "__undefined__" },
#endif
#ifdef X86_64_ACCTON_AS7712_32X_CONFIG_LOG_OPTIONS_DEFAULT
{ __x86_64_accton_as7712_32x_config_STRINGIFY_NAME(X86_64_ACCTON_AS7712_32X_CONFIG_LOG_OPTIONS_DEFAULT), __x86_64_accton_as7712_32x_config_STRINGIFY_VALUE(X86_64_ACCTON_AS7712_32X_CONFIG_LOG_OPTIONS_DEFAULT) },
#else
{ X86_64_ACCTON_AS7712_32X_CONFIG_LOG_OPTIONS_DEFAULT(__x86_64_accton_as7712_32x_config_STRINGIFY_NAME), "__undefined__" },
#endif
#ifdef X86_64_ACCTON_AS7712_32X_CONFIG_LOG_BITS_DEFAULT
{ __x86_64_accton_as7712_32x_config_STRINGIFY_NAME(X86_64_ACCTON_AS7712_32X_CONFIG_LOG_BITS_DEFAULT), __x86_64_accton_as7712_32x_config_STRINGIFY_VALUE(X86_64_ACCTON_AS7712_32X_CONFIG_LOG_BITS_DEFAULT) },
#else
{ X86_64_ACCTON_AS7712_32X_CONFIG_LOG_BITS_DEFAULT(__x86_64_accton_as7712_32x_config_STRINGIFY_NAME), "__undefined__" },
#endif
#ifdef X86_64_ACCTON_AS7712_32X_CONFIG_LOG_CUSTOM_BITS_DEFAULT
{ __x86_64_accton_as7712_32x_config_STRINGIFY_NAME(X86_64_ACCTON_AS7712_32X_CONFIG_LOG_CUSTOM_BITS_DEFAULT), __x86_64_accton_as7712_32x_config_STRINGIFY_VALUE(X86_64_ACCTON_AS7712_32X_CONFIG_LOG_CUSTOM_BITS_DEFAULT) },
#else
{ X86_64_ACCTON_AS7712_32X_CONFIG_LOG_CUSTOM_BITS_DEFAULT(__x86_64_accton_as7712_32x_config_STRINGIFY_NAME), "__undefined__" },
#endif
#ifdef X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB
{ __x86_64_accton_as7712_32x_config_STRINGIFY_NAME(X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB), __x86_64_accton_as7712_32x_config_STRINGIFY_VALUE(X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB) },
#else
{ X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_STDLIB(__x86_64_accton_as7712_32x_config_STRINGIFY_NAME), "__undefined__" },
#endif
#ifdef X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS
{ __x86_64_accton_as7712_32x_config_STRINGIFY_NAME(X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS), __x86_64_accton_as7712_32x_config_STRINGIFY_VALUE(X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS) },
#else
{ X86_64_ACCTON_AS7712_32X_CONFIG_PORTING_INCLUDE_STDLIB_HEADERS(__x86_64_accton_as7712_32x_config_STRINGIFY_NAME), "__undefined__" },
#endif
#ifdef X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_UCLI
{ __x86_64_accton_as7712_32x_config_STRINGIFY_NAME(X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_UCLI), __x86_64_accton_as7712_32x_config_STRINGIFY_VALUE(X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_UCLI) },
#else
{ X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_UCLI(__x86_64_accton_as7712_32x_config_STRINGIFY_NAME), "__undefined__" },
#endif
#ifdef X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION
{ __x86_64_accton_as7712_32x_config_STRINGIFY_NAME(X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION), __x86_64_accton_as7712_32x_config_STRINGIFY_VALUE(X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION) },
#else
{ X86_64_ACCTON_AS7712_32X_CONFIG_INCLUDE_DEFAULT_FAN_DIRECTION(__x86_64_accton_as7712_32x_config_STRINGIFY_NAME), "__undefined__" },
#endif
{ NULL, NULL }
};
#undef __x86_64_accton_as7712_32x_config_STRINGIFY_VALUE
#undef __x86_64_accton_as7712_32x_config_STRINGIFY_NAME
const char*
x86_64_accton_as7712_32x_config_lookup(const char* setting)
{
int i;
for(i = 0; x86_64_accton_as7712_32x_config_settings[i].name; i++) {
if(!strcmp(x86_64_accton_as7712_32x_config_settings[i].name, setting)) {
return x86_64_accton_as7712_32x_config_settings[i].value;
}
}
return NULL;
}
int
x86_64_accton_as7712_32x_config_show(struct aim_pvs_s* pvs)
{
int i;
for(i = 0; x86_64_accton_as7712_32x_config_settings[i].name; i++) {
aim_printf(pvs, "%s = %s\n", x86_64_accton_as7712_32x_config_settings[i].name, x86_64_accton_as7712_32x_config_settings[i].value);
}
return i;
}
/* <auto.end.cdefs(x86_64_accton_as7712_32x_CONFIG_HEADER).source> */

10
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/x86_64_accton_as7712_32x_enums.c Normal file
View File

@@ -0,0 +1,10 @@
/**************************************************************************//**
*
*
*
*****************************************************************************/
#include <x86_64_accton_as7712_32x/x86_64_accton_as7712_32x_config.h>
/* <--auto.start.enum(ALL).source> */
/* <auto.end.enum(ALL).source> */

12
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/x86_64_accton_as7712_32x_int.h Normal file
View File

@@ -0,0 +1,12 @@
/**************************************************************************//**
*
* x86_64_accton_as7712_32x Internal Header
*
*****************************************************************************/
#ifndef __x86_64_accton_as7712_32x_INT_H__
#define __x86_64_accton_as7712_32x_INT_H__
#include <x86_64_accton_as7712_32x/x86_64_accton_as7712_32x_config.h>
#endif /* __x86_64_accton_as7712_32x_INT_H__ */

17
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/x86_64_accton_as7712_32x_log.c Normal file
View File

@@ -0,0 +1,17 @@
/**************************************************************************//**
*
*
*
*****************************************************************************/
#include <x86_64_accton_as7712_32x/x86_64_accton_as7712_32x_config.h>
#include "x86_64_accton_as7712_32x_log.h"
/*
* x86_64_accton_as7712_32x log struct.
*/
AIM_LOG_STRUCT_DEFINE(
X86_64_ACCTON_AS7712_32X_CONFIG_LOG_OPTIONS_DEFAULT,
X86_64_ACCTON_AS7712_32X_CONFIG_LOG_BITS_DEFAULT,
NULL, /* Custom log map */
X86_64_ACCTON_AS7712_32X_CONFIG_LOG_CUSTOM_BITS_DEFAULT
);

12
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/x86_64_accton_as7712_32x_log.h Normal file
View File

@@ -0,0 +1,12 @@
/**************************************************************************//**
*
*
*
*****************************************************************************/
#ifndef __x86_64_accton_as7712_32x_LOG_H__
#define __x86_64_accton_as7712_32x_LOG_H__
#define AIM_LOG_MODULE_NAME x86_64_accton_as7712_32x
#include <AIM/aim_log.h>
#endif /* __x86_64_accton_as7712_32x_LOG_H__ */

24
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/x86_64_accton_as7712_32x_module.c Normal file
View File

@@ -0,0 +1,24 @@
/**************************************************************************//**
*
*
*
*****************************************************************************/
#include <x86_64_accton_as7712_32x/x86_64_accton_as7712_32x_config.h>
#include "x86_64_accton_as7712_32x_log.h"
static int
datatypes_init__(void)
{
#define x86_64_accton_as7712_32x_ENUMERATION_ENTRY(_enum_name, _desc) AIM_DATATYPE_MAP_REGISTER(_enum_name, _enum_name##_map, _desc, AIM_LOG_INTERNAL);
#include <x86_64_accton_as7712_32x/x86_64_accton_as7712_32x.x>
return 0;
}
void __x86_64_accton_as7712_32x_module_init__(void)
{
AIM_LOG_STRUCT_REGISTER();
datatypes_init__();
}
int __onlp_platform_version__ = 1;

50
packages/platforms/accton/x86-64/as7712-32x/onlp/builds/x86_64_accton_as7712_32x/module/src/x86_64_accton_as7712_32x_ucli.c Normal file
View File

@@ -0,0 +1,50 @@
/**************************************************************************//**
*
*
*
*****************************************************************************/
#include <x86_64_accton_as7712_32x/x86_64_accton_as7712_32x_config.h>
#if x86_64_accton_as7712_32x_CONFIG_INCLUDE_UCLI == 1
#include <uCli/ucli.h>
#include <uCli/ucli_argparse.h>
#include <uCli/ucli_handler_macros.h>
static ucli_status_t
x86_64_accton_as7712_32x_ucli_ucli__config__(ucli_context_t* uc)
{
UCLI_HANDLER_MACRO_MODULE_CONFIG(x86_64_accton_as7712_32x)
}
/* <auto.ucli.handlers.start> */
/* <auto.ucli.handlers.end> */
static ucli_module_t
x86_64_accton_as7712_32x_ucli_module__ =
{
"x86_64_accton_as7712_32x_ucli",
NULL,
x86_64_accton_as7712_32x_ucli_ucli_handlers__,
NULL,
NULL,
};
ucli_node_t*
x86_64_accton_as7712_32x_ucli_node_create(void)
{
ucli_node_t* n;
ucli_module_init(&x86_64_accton_as7712_32x_ucli_module__);
n = ucli_node_create("x86_64_accton_as7712_32x", NULL, &x86_64_accton_as7712_32x_ucli_module__);
ucli_node_subnode_add(n, ucli_module_log_node_create("x86_64_accton_as7712_32x"));
return n;
}
#else
void*
x86_64_accton_as7712_32x_ucli_node_create(void)
{
return NULL;
}
#endif

1
packages/platforms/accton/x86-64/as7712-32x/platform-config/Makefile Normal file
View File

@@ -0,0 +1 @@
include $(ONL)/make/pkg.mk

1
packages/platforms/accton/x86-64/as7712-32x/platform-config/r0/Makefile Normal file
View File

@@ -0,0 +1 @@
include $(ONL)/make/pkg.mk

1
packages/platforms/accton/x86-64/as7712-32x/platform-config/r0/PKG.yml Normal file
View File

@@ -0,0 +1 @@
!include $ONL_TEMPLATES/platform-config-platform.yml ARCH=amd64 VENDOR=accton BASENAME=x86-64-accton-as7712-32x REVISION=r0

31
packages/platforms/accton/x86-64/as7712-32x/platform-config/r0/src/lib/x86-64-accton-as7712-32x-r0.yml Normal file
View File

@@ -0,0 +1,31 @@
---
######################################################################
#
# platform-config for AS7712
#
######################################################################
x86-64-accton-as7712-32x-r0:
grub:
serial: >-
--port=0x2f8
--speed=115200
--word=8
--parity=no
--stop=1
kernel:
<<: *kernel-4-14
args: >-
nopat
console=ttyS1,115200n8
##network
## interfaces:
## ma1:
## name: ~
## syspath: pci0000:00/0000:00:14.0

129
packages/platforms/accton/x86-64/as7712-32x/platform-config/r0/src/python/x86_64_accton_as7712_32x_r0/__init__.py Normal file
View File

@@ -0,0 +1,129 @@
from onl.platform.base import *
from onl.platform.accton import *
class OnlPlatform_x86_64_accton_as7712_32x_r0(OnlPlatformAccton,
OnlPlatformPortConfig_32x100):
PLATFORM='x86-64-accton-as7712-32x-r0'
MODEL="AS7712-32X"
SYS_OBJECT_ID=".7712.32"
def baseconfig(self):
self.insmod('optoe')
self.insmod('ym2651y')
self.insmod('accton_i2c_cpld')
for m in [ 'fan', 'cpld1', 'psu', 'leds' ]:
self.insmod("x86-64-accton-as7712-32x-%s.ko" % m)
########### initialize I2C bus 0 ###########
self.new_i2c_devices([
# initialize multiplexer (PCA9548)
('pca9548', 0x76, 0),
# initiate chassis fan
('as7712_32x_fan', 0x66, 2),
# inititate LM75
('lm75', 0x48, 3),
('lm75', 0x49, 3),
('lm75', 0x4a, 3),
('lm75', 0x4b, 3),
('as7712_32x_cpld1', 0x60, 4),
('accton_i2c_cpld', 0x62, 5),
('accton_i2c_cpld', 0x64, 6),
])
########### initialize I2C bus 1 ###########
self.new_i2c_devices(
[
# initiate multiplexer (PCA9548)
('pca9548', 0x71, 1),
# initiate PSU-1
('as7712_32x_psu1', 0x53, 11),
('ym2651', 0x5b, 11),
# initiate PSU-2
('as7712_32x_psu2', 0x50, 10),
('ym2651', 0x58, 10),
# initiate multiplexer (PCA9548)
('pca9548', 0x72, 1),
('pca9548', 0x73, 1),
('pca9548', 0x74, 1),
('pca9548', 0x75, 1),
]
)
# initialize QSFP port 1~32
self.new_i2c_devices([
('optoe1', 0x50, 18),
('optoe1', 0x50, 19),
('optoe1', 0x50, 20),
('optoe1', 0x50, 21),
('optoe1', 0x50, 22),
('optoe1', 0x50, 23),
('optoe1', 0x50, 24),
('optoe1', 0x50, 25),
('optoe1', 0x50, 26),
('optoe1', 0x50, 27),
('optoe1', 0x50, 28),
('optoe1', 0x50, 29),
('optoe1', 0x50, 30),
('optoe1', 0x50, 31),
('optoe1', 0x50, 32),
('optoe1', 0x50, 33),
('optoe1', 0x50, 34),
('optoe1', 0x50, 35),
('optoe1', 0x50, 36),
('optoe1', 0x50, 37),
('optoe1', 0x50, 38),
('optoe1', 0x50, 39),
('optoe1', 0x50, 40),
('optoe1', 0x50, 41),
('optoe1', 0x50, 42),
('optoe1', 0x50, 43),
('optoe1', 0x50, 44),
('optoe1', 0x50, 45),
('optoe1', 0x50, 46),
('optoe1', 0x50, 47),
('optoe1', 0x50, 48),
('optoe1', 0x50, 49),
])
subprocess.call('echo port9 > /sys/bus/i2c/devices/18-0050/port_name', shell=True)
subprocess.call('echo port10 > /sys/bus/i2c/devices/19-0050/port_name', shell=True)
subprocess.call('echo port11 > /sys/bus/i2c/devices/20-0050/port_name', shell=True)
subprocess.call('echo port12 > /sys/bus/i2c/devices/21-0050/port_name', shell=True)
subprocess.call('echo port1 > /sys/bus/i2c/devices/22-0050/port_name', shell=True)
subprocess.call('echo port2 > /sys/bus/i2c/devices/23-0050/port_name', shell=True)
subprocess.call('echo port3 > /sys/bus/i2c/devices/24-0050/port_name', shell=True)
subprocess.call('echo port4 > /sys/bus/i2c/devices/25-0050/port_name', shell=True)
subprocess.call('echo port6 > /sys/bus/i2c/devices/26-0050/port_name', shell=True)
subprocess.call('echo port5 > /sys/bus/i2c/devices/27-0050/port_name', shell=True)
subprocess.call('echo port8 > /sys/bus/i2c/devices/28-0050/port_name', shell=True)
subprocess.call('echo port7 > /sys/bus/i2c/devices/29-0050/port_name', shell=True)
subprocess.call('echo port13 > /sys/bus/i2c/devices/30-0050/port_name', shell=True)
subprocess.call('echo port14 > /sys/bus/i2c/devices/31-0050/port_name', shell=True)
subprocess.call('echo port15 > /sys/bus/i2c/devices/32-0050/port_name', shell=True)
subprocess.call('echo port16 > /sys/bus/i2c/devices/33-0050/port_name', shell=True)
subprocess.call('echo port17 > /sys/bus/i2c/devices/34-0050/port_name', shell=True)
subprocess.call('echo port18 > /sys/bus/i2c/devices/35-0050/port_name', shell=True)
subprocess.call('echo port19 > /sys/bus/i2c/devices/36-0050/port_name', shell=True)
subprocess.call('echo port20 > /sys/bus/i2c/devices/37-0050/port_name', shell=True)
subprocess.call('echo port25 > /sys/bus/i2c/devices/38-0050/port_name', shell=True)
subprocess.call('echo port26 > /sys/bus/i2c/devices/39-0050/port_name', shell=True)
subprocess.call('echo port27 > /sys/bus/i2c/devices/40-0050/port_name', shell=True)
subprocess.call('echo port28 > /sys/bus/i2c/devices/41-0050/port_name', shell=True)
subprocess.call('echo port29 > /sys/bus/i2c/devices/42-0050/port_name', shell=True)
subprocess.call('echo port30 > /sys/bus/i2c/devices/43-0050/port_name', shell=True)
subprocess.call('echo port31 > /sys/bus/i2c/devices/44-0050/port_name', shell=True)
subprocess.call('echo port32 > /sys/bus/i2c/devices/45-0050/port_name', shell=True)
subprocess.call('echo port21 > /sys/bus/i2c/devices/46-0050/port_name', shell=True)
subprocess.call('echo port22 > /sys/bus/i2c/devices/47-0050/port_name', shell=True)
subprocess.call('echo port23 > /sys/bus/i2c/devices/48-0050/port_name', shell=True)
subprocess.call('echo port24 > /sys/bus/i2c/devices/49-0050/port_name', shell=True)
self.new_i2c_device('24c02', 0x57, 1)
return True