1070 lines
29 KiB
C
1070 lines
29 KiB
C
/*
|
|
* smc.c - The CPLD driver for E1031 System Management.
|
|
* The driver implement sysfs to access CPLD register on the E1031 via LPC bus.
|
|
* Copyright (C) 2018 Celestica Corp.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include <linux/acpi.h>
|
|
#include <linux/dmi.h>
|
|
#include <linux/err.h>
|
|
#include <linux/hwmon-sysfs.h>
|
|
#include <linux/init.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/io.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/kdev_t.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/leds.h>
|
|
#include <linux/module.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/stddef.h>
|
|
#include <linux/string.h>
|
|
#include <linux/types.h>
|
|
#include <uapi/linux/stat.h>
|
|
|
|
|
|
#define DRIVER_NAME "e1031.smc"
|
|
|
|
/**
|
|
* CPLD register address for read and write.
|
|
*/
|
|
#define VERSION 0x0200
|
|
#define SCRATCH 0x0201
|
|
#define BROAD_ID 0x0202
|
|
|
|
/* SEPERATE RESET
|
|
* [7:5] RESERVED
|
|
* [4] RESET PCIE
|
|
* [3] RESET USBHUB
|
|
* [2] RESET B50282
|
|
* [1] RESET PCA9548
|
|
* [0] RESET BCM54616
|
|
* 1: not reset, 0: reset
|
|
*/
|
|
#define SPR_RESET 0x0222
|
|
|
|
/* PSU STATUS
|
|
* [7] PSUR_ACOK
|
|
* [6] PSUR_PWOK
|
|
* [5] PSUR_ALRT
|
|
* [4] PSUR_PRS
|
|
* [3] PSUL_ACOK
|
|
* [2] PSUL_PWOK
|
|
* [1] PSUL_ALRT
|
|
* [0] PSUL_PRS
|
|
*/
|
|
#define PSU_STAT 0x0204
|
|
#define PSUR_ACOK 7
|
|
#define PSUR_PWOK 6
|
|
#define PSUR_ALRT 5
|
|
#define PSUR_PRS 4
|
|
#define PSUL_ACOK 3
|
|
#define PSUL_PWOK 2
|
|
#define PSUL_ALRT 1
|
|
#define PSUL_PRS 0
|
|
|
|
/* FAN LED CTRL
|
|
* [7:3] RESERVED
|
|
* [2:0] LED CTRL
|
|
*/
|
|
#define FAN_LED_1 0x0205
|
|
#define FAN_LED_2 0x0206
|
|
#define FAN_LED_3 0x0207
|
|
|
|
enum FAN_LED {
|
|
fan_led_grn = 0,
|
|
fan_led_grn_bnk,
|
|
fan_led_amb,
|
|
fan_led_amb_bnk,
|
|
fan_led_off
|
|
} fan_led;
|
|
|
|
#define LED_OPMOD 0x0208
|
|
#define LED_TEST 0x0209
|
|
|
|
/* SYSTEM LED
|
|
* [7:4] RESERVED
|
|
* [3:2] STATUS LED
|
|
* [1:0] MASTER LED
|
|
*/
|
|
#define LED_FPS 0x020a
|
|
|
|
enum STAT_LED {
|
|
stat_led_off = 0,
|
|
stat_led_grn,
|
|
stat_led_grn_bnk
|
|
} stat_led;
|
|
|
|
enum MASTER_LED {
|
|
master_led_off = 0,
|
|
master_led_grn,
|
|
master_led_amb
|
|
} master_led;
|
|
|
|
/* FAN DIRECTION STAT
|
|
* [7:4] RESERVED
|
|
* [3] USB HUB STAT
|
|
* [2:0] FAN_DIR
|
|
*/
|
|
#define DEV_STAT 0x020c
|
|
#define FAN_3 2
|
|
#define FAN_2 1
|
|
#define FAN_1 0
|
|
|
|
/* FAN STATUS
|
|
* [7:5] FAN STATUS
|
|
* [4] FAN INTERRUPT
|
|
* [3:0] PSU ALERT
|
|
*/
|
|
#define FAN_STAT 0x0234
|
|
#define FAN3_PRS 7
|
|
#define FAN2_PRS 6
|
|
#define FAN1_PRS 5
|
|
|
|
/* SFP PORT INT TRIGGER MODE
|
|
* [7:6] RESERVED
|
|
* [5:4] RXLOS
|
|
* [3:2] MODABS
|
|
* [1:0] TXFAULT
|
|
* 00: falling edge,
|
|
* 01: rising edge,
|
|
* 10: Both edges,
|
|
* 11: low level detect
|
|
*/
|
|
#define TRIG_MODE 0x0240
|
|
#define TXFAULT_TRIG 0
|
|
#define MODABS_TRIG 2
|
|
#define RXLOS_TRIG 4
|
|
|
|
|
|
/* SFP PORT STATUS
|
|
* [7:4] RESERVED
|
|
* [3:0] TX_FAULT / MODABS / RXLOS
|
|
*/
|
|
#define SFP_TXFAULT 0x0242
|
|
#define SFP_MODABS 0x0243
|
|
#define SFP_RXLOS 0x0244
|
|
|
|
/* SFP PORT INTERRUPT
|
|
* [7:4] RESERVED
|
|
* [3:0] TX_FAULT / MODABS / RXLOS
|
|
* 1: int, 0: no int
|
|
*/
|
|
#define TXFAULT_INT 0x0246
|
|
#define MODABS_INT 0x0247
|
|
#define RXLOS_INT 0x0248
|
|
|
|
/* INTERRUPT MASK REGISTER
|
|
* [7:4] RESERVED
|
|
* [3:0] TX_FAULT / MODABS / RXLOS
|
|
* 1: mask, 0: not mask
|
|
*/
|
|
#define TXFAULT_MSK 0x024A
|
|
#define MODABS_MSK 0x024B
|
|
#define RXLOS_MSK 0x024C
|
|
|
|
/* SFP PORT CTRL
|
|
* [7:4] RATE SEL (RS0/RS1)
|
|
* [3:0] TX_DIS
|
|
*/
|
|
#define SFP_TXCTRL 0x0255
|
|
|
|
struct cpld_data {
|
|
struct mutex cpld_lock;
|
|
uint16_t read_addr;
|
|
struct device *fpp_node;
|
|
struct device *sfp_devices[4];
|
|
};
|
|
|
|
struct sfp_device_data {
|
|
int portid;
|
|
};
|
|
|
|
struct class *celplatform;
|
|
struct cpld_data *cpld_data;
|
|
|
|
struct index_device_attribute {
|
|
struct device_attribute dev_attr;
|
|
int index;
|
|
};
|
|
|
|
static ssize_t scratch_show(struct device *dev, struct device_attribute *devattr,
|
|
char *buf)
|
|
{
|
|
unsigned char data = 0;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(SCRATCH);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "0x%2.2x\n", data);
|
|
}
|
|
|
|
static ssize_t scratch_store(struct device *dev, struct device_attribute *devattr,
|
|
const char *buf, size_t count)
|
|
{
|
|
unsigned long data;
|
|
char *last;
|
|
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = (uint16_t)strtoul(buf, &last, 16);
|
|
if (data == 0 && buf == last) {
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return -EINVAL;
|
|
}
|
|
outb(data, SCRATCH);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return count;
|
|
}
|
|
|
|
|
|
static ssize_t version_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
int len = 0;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
len = sprintf(buf, "0x%2.2x\n", inb(VERSION));
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return len;
|
|
}
|
|
|
|
static ssize_t getreg_store(struct device *dev, struct device_attribute *devattr,
|
|
const char *buf, size_t count)
|
|
{
|
|
uint16_t addr;
|
|
char *last;
|
|
|
|
addr = (uint16_t)strtoul(buf, &last, 16);
|
|
if (addr == 0 && buf == last) {
|
|
return -EINVAL;
|
|
}
|
|
cpld_data->read_addr = addr;
|
|
return count;
|
|
}
|
|
|
|
static ssize_t getreg_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
int len = 0;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
len = sprintf(buf, "0x%2.2x\n", inb(cpld_data->read_addr));
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return len;
|
|
}
|
|
|
|
static ssize_t setreg_store(struct device *dev, struct device_attribute *devattr,
|
|
const char *buf, size_t count)
|
|
{
|
|
uint16_t addr;
|
|
uint8_t value;
|
|
char *tok;
|
|
char clone[count];
|
|
char *pclone = clone;
|
|
char *last;
|
|
|
|
strcpy(clone, buf);
|
|
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
tok = strsep((char**)&pclone, " ");
|
|
if (tok == NULL) {
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return -EINVAL;
|
|
}
|
|
addr = (uint16_t)strtoul(tok, &last, 16);
|
|
if (addr == 0 && tok == last) {
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return -EINVAL;
|
|
}
|
|
|
|
tok = strsep((char**)&pclone, " ");
|
|
if (tok == NULL) {
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return -EINVAL;
|
|
}
|
|
value = (uint8_t)strtoul(tok, &last, 16);
|
|
if (value == 0 && tok == last) {
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return -EINVAL;
|
|
}
|
|
|
|
outb(value, addr);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* @brief Show status led
|
|
* @param dev kernel device
|
|
* @param devattr kernel device attribute
|
|
* @param buf buffer for get value
|
|
* @return led state - off/on/blink
|
|
*/
|
|
static ssize_t status_led_show(struct device *dev, struct device_attribute *devattr,
|
|
char *buf)
|
|
{
|
|
unsigned char data = 0;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(LED_FPS);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
data = data & 0xc;
|
|
return sprintf(buf, "%s\n",
|
|
data == stat_led_grn ? "on" : data == stat_led_grn_bnk ? "blink" : "off");
|
|
}
|
|
|
|
/**
|
|
* @brief Set the status led
|
|
* @param dev kernel device
|
|
* @param devattr kernel device attribute
|
|
* @param buf buffer of set value - off/on/blink
|
|
* @param count number of bytes in buffer
|
|
* @return number of bytes written, or error code < 0.
|
|
*/
|
|
static ssize_t status_led_store(struct device *dev, struct device_attribute *devattr,
|
|
const char *buf, size_t count)
|
|
{
|
|
unsigned char led_status, data;
|
|
|
|
if (sysfs_streq(buf, "off")) {
|
|
led_status = stat_led_off;
|
|
} else if (sysfs_streq(buf, "on")) {
|
|
led_status = stat_led_grn;
|
|
} else if (sysfs_streq(buf, "blink")) {
|
|
led_status = stat_led_grn_bnk;
|
|
} else {
|
|
count = -EINVAL;
|
|
return count;
|
|
}
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(LED_FPS);
|
|
data = data & ~(0xc);
|
|
data = data | ( led_status << 2 );
|
|
outb(data, LED_FPS);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* @brief Show master led
|
|
* @param dev kernel device
|
|
* @param devattr kernel device attribute
|
|
* @param buf buffer for get value
|
|
* @return led state - off/green/amber
|
|
*/
|
|
static ssize_t master_led_show(struct device *dev, struct device_attribute *devattr,
|
|
char *buf)
|
|
{
|
|
unsigned char data = 0;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(LED_FPS);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
data = data & 0x3;
|
|
return sprintf(buf, "%s\n",
|
|
data == master_led_grn ? "on" : data == master_led_amb ? "amber" : "off");
|
|
}
|
|
|
|
/**
|
|
* @brief Set the master led
|
|
* @param dev kernel device
|
|
* @param devattr kernel device attribute
|
|
* @param buf buffer of set value - off/green/amber
|
|
* @param count number of bytes in buffer
|
|
* @return number of bytes written, or error code < 0.
|
|
*/
|
|
static ssize_t master_led_store(struct device *dev, struct device_attribute *devattr,
|
|
const char *buf, size_t count)
|
|
{
|
|
unsigned char led_status, data;
|
|
|
|
if (sysfs_streq(buf, "off")) {
|
|
led_status = master_led_off;
|
|
} else if (sysfs_streq(buf, "green")) {
|
|
led_status = master_led_grn;
|
|
} else if (sysfs_streq(buf, "amber")) {
|
|
led_status = master_led_amb;
|
|
} else {
|
|
count = -EINVAL;
|
|
return count;
|
|
}
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(LED_FPS);
|
|
data = data & ~(0x3);
|
|
data = data | led_status;
|
|
outb(data, LED_FPS);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return count;
|
|
}
|
|
|
|
static ssize_t psuL_prs_show(struct device *dev, struct device_attribute *devattr,
|
|
char *buf)
|
|
{
|
|
unsigned char data = 0;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(PSU_STAT);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "%d\n", ~(data >> PSUL_PRS) & 1U);
|
|
}
|
|
|
|
static ssize_t psuR_prs_show(struct device *dev, struct device_attribute *devattr,
|
|
char *buf)
|
|
{
|
|
unsigned char data = 0;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(PSU_STAT);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "%d\n", ~(data >> PSUR_PRS) & 1U);
|
|
}
|
|
static DEVICE_ATTR_RO(psuR_prs);
|
|
|
|
static ssize_t psuL_status_show(struct device *dev, struct device_attribute *devattr,
|
|
char *buf)
|
|
{
|
|
unsigned char data = 0;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(PSU_STAT);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
data = ( data >> PSUL_PWOK ) & 0x3;
|
|
return sprintf(buf, "%d\n", data == 0x3 );
|
|
}
|
|
|
|
static ssize_t psuR_status_show(struct device *dev, struct device_attribute *devattr,
|
|
char *buf)
|
|
{
|
|
unsigned char data = 0;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(PSU_STAT);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
data = ( data >> PSUR_PWOK ) & 0x3;
|
|
return sprintf(buf, "%d\n", data == 0x3 );
|
|
}
|
|
|
|
|
|
static ssize_t fan_dir_show(struct device *dev, struct device_attribute *devattr,
|
|
char *buf)
|
|
{
|
|
struct sensor_device_attribute *sa = to_sensor_dev_attr(devattr);
|
|
int index = sa->index;
|
|
unsigned char data = 0;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(DEV_STAT);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
data = ( data >> index ) & 1U;
|
|
return sprintf(buf, "%s\n", data ? "B2F" : "F2B" );
|
|
}
|
|
|
|
static ssize_t fan_prs_show(struct device *dev, struct device_attribute *devattr,
|
|
char *buf)
|
|
{
|
|
struct sensor_device_attribute *sa = to_sensor_dev_attr(devattr);
|
|
int index = sa->index;
|
|
unsigned char data = 0;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(FAN_STAT);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
data = ( data >> index ) & 1U;
|
|
return sprintf(buf, "%d\n", data);
|
|
}
|
|
|
|
static ssize_t sfp_txfault_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char data;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(SFP_TXFAULT);
|
|
data = data & 0x0F;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "0x%x\n", data);
|
|
}
|
|
|
|
static ssize_t sfp_modabs_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char data;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(SFP_MODABS);
|
|
data = data & 0x0F;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "0x%x\n", data);
|
|
}
|
|
|
|
static ssize_t sfp_rxlos_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char data;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(SFP_RXLOS);
|
|
data = data & 0x0F;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "0x%x\n", data);
|
|
}
|
|
|
|
static ssize_t sfp_txdis_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char data;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(SFP_TXCTRL);
|
|
data = data & 0x0F;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "0x%x\n", data);
|
|
}
|
|
|
|
static ssize_t sfp_txdis_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
long value;
|
|
ssize_t status;
|
|
unsigned char data;
|
|
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
status = kstrtol(buf, 0, &value);
|
|
if (status == 0) {
|
|
data = inb(SFP_TXCTRL);
|
|
data = data & ~(0x0F);
|
|
data = data | (value & 0x0F);
|
|
outb(data, SFP_TXCTRL);
|
|
status = size;
|
|
}
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return status;
|
|
}
|
|
|
|
static ssize_t sfp_rs_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char data;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(SFP_TXCTRL) >> 4;
|
|
data = data & 0x0F;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "0x%x\n", data);
|
|
}
|
|
|
|
static ssize_t sfp_rs_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
long value;
|
|
ssize_t status;
|
|
unsigned char data;
|
|
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
status = kstrtol(buf, 0, &value);
|
|
value = (value & 0x0F) << 4;
|
|
if (status == 0) {
|
|
data = inb(SFP_TXCTRL);
|
|
data = data & ~(0xF0);
|
|
data = data | value;
|
|
outb(data, SFP_TXCTRL);
|
|
status = size;
|
|
}
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Show the avaliable interrupt trigger mode.
|
|
* "none" means the interrupt is masked.
|
|
*
|
|
* @return Current trigger mode.
|
|
*/
|
|
static ssize_t txfault_trig_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char mode;
|
|
char *mode_str[5] = {"falling", "rising", "both", "low"};
|
|
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
mode = inb(TRIG_MODE) >> TXFAULT_TRIG;
|
|
mode = mode & 0x3;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "%s\n", mode_str[mode]);
|
|
}
|
|
|
|
/**
|
|
* @brief Set the trigger mode of each interrupt type.
|
|
* Only one trigger mode allow in a type.
|
|
*
|
|
* @param buf The trigger mode of follwings
|
|
* "falling", "rising", "both"
|
|
*/
|
|
static ssize_t txfault_trig_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
ssize_t status;
|
|
unsigned char data, trig_mode;
|
|
|
|
if (sysfs_streq(buf, "falling")) {
|
|
trig_mode = 0;
|
|
} else if (sysfs_streq(buf, "rising")) {
|
|
trig_mode = 1;
|
|
} else if (sysfs_streq(buf, "both")) {
|
|
trig_mode = 2;
|
|
} else if (sysfs_streq(buf, "low")) {
|
|
trig_mode = 3;
|
|
} else {
|
|
status = -EINVAL;
|
|
return status;
|
|
}
|
|
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(TRIG_MODE);
|
|
data = data & ~(0x03 << TXFAULT_TRIG);
|
|
data = data | trig_mode << TXFAULT_TRIG;
|
|
outb(data, TRIG_MODE);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
status = size;
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Show the avaliable interrupt trigger mode.
|
|
* "none" means the interrupt is masked.
|
|
*
|
|
* @return Current trigger mode.
|
|
*/
|
|
static ssize_t modabs_trig_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char mode;
|
|
char *mode_str[5] = {"falling", "rising", "both", "low"};
|
|
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
mode = inb(TRIG_MODE) >> MODABS_TRIG;
|
|
mode = mode & 0x3;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "%s\n", mode_str[mode]);
|
|
}
|
|
|
|
/**
|
|
* @brief Set the trigger mode of each interrupt type.
|
|
* Only one trigger mode allow in a type.
|
|
*
|
|
* @param buf The trigger mode of follwings
|
|
* "falling", "rising", "both", "low"
|
|
*/
|
|
static ssize_t modabs_trig_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
ssize_t status;
|
|
unsigned char data, trig_mode;
|
|
|
|
if (sysfs_streq(buf, "falling")) {
|
|
trig_mode = 0;
|
|
} else if (sysfs_streq(buf, "rising")) {
|
|
trig_mode = 1;
|
|
} else if (sysfs_streq(buf, "both")) {
|
|
trig_mode = 2;
|
|
} else if (sysfs_streq(buf, "low")) {
|
|
trig_mode = 3;
|
|
} else {
|
|
status = -EINVAL;
|
|
return status;
|
|
}
|
|
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(TRIG_MODE);
|
|
data = data & ~(0x03 << MODABS_TRIG);
|
|
data = data | trig_mode << MODABS_TRIG;
|
|
outb(data, TRIG_MODE);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
status = size;
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Show the avaliable interrupt trigger mode.
|
|
* "none" means the interrupt is masked.
|
|
*
|
|
* @return Current trigger mode.
|
|
*/
|
|
static ssize_t rxlos_trig_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char mode;
|
|
char *mode_str[5] = {"falling", "rising", "both", "low"};
|
|
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
mode = inb(TRIG_MODE) >> RXLOS_TRIG;
|
|
mode = mode & 0x3;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "%s\n", mode_str[mode]);
|
|
}
|
|
|
|
/**
|
|
* @brief Set the trigger mode of each interrupt type.
|
|
* Only one trigger mode allow in a type.
|
|
*
|
|
* @param buf The trigger mode of follwings
|
|
* "falling", "rising", "both", "low"
|
|
*/
|
|
static ssize_t rxlos_trig_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
ssize_t status;
|
|
unsigned char data, trig_mode;
|
|
|
|
if (sysfs_streq(buf, "falling")) {
|
|
trig_mode = 0;
|
|
} else if (sysfs_streq(buf, "rising")) {
|
|
trig_mode = 1;
|
|
} else if (sysfs_streq(buf, "both")) {
|
|
trig_mode = 2;
|
|
} else if (sysfs_streq(buf, "low")) {
|
|
trig_mode = 3;
|
|
} else {
|
|
status = -EINVAL;
|
|
return status;
|
|
}
|
|
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(TRIG_MODE);
|
|
data = data & ~(0x03 << RXLOS_TRIG);
|
|
data = data | trig_mode << RXLOS_TRIG;
|
|
outb(data, TRIG_MODE);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
status = size;
|
|
return status;
|
|
}
|
|
|
|
static ssize_t txfault_int_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char data;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(TXFAULT_INT);
|
|
data = data & 0x0F;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "0x%x\n", data);
|
|
}
|
|
|
|
static ssize_t modabs_int_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char data;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(MODABS_INT);
|
|
data = data & 0x0F;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "0x%x\n", data);
|
|
}
|
|
|
|
static ssize_t rxlos_int_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char data;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(RXLOS_INT);
|
|
data = data & 0x0F;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "0x%x\n", data);
|
|
}
|
|
|
|
static ssize_t txfault_mask_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char data;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(TXFAULT_MSK);
|
|
data = data & 0x0F;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "0x%x\n", data);
|
|
}
|
|
|
|
static ssize_t txfault_mask_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
long value;
|
|
ssize_t status;
|
|
|
|
status = kstrtol(buf, 0, &value);
|
|
value = value & 0x0F;
|
|
if (status == 0) {
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
outb(value, TXFAULT_MSK);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
status = size;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static ssize_t modabs_mask_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char data;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(MODABS_MSK);
|
|
data = data & 0x0F;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "0x%x\n", data);
|
|
}
|
|
|
|
static ssize_t modabs_mask_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
long value;
|
|
ssize_t status;
|
|
|
|
status = kstrtol(buf, 0, &value);
|
|
value = value & 0x0F;
|
|
if (status == 0) {
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
outb(value, MODABS_MSK);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
status = size;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static ssize_t rxlos_mask_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
unsigned char data;
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(RXLOS_MSK);
|
|
data = data & 0x0F;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "0x%x\n", data);
|
|
}
|
|
|
|
static ssize_t rxlos_mask_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
long value;
|
|
ssize_t status;
|
|
|
|
status = kstrtol(buf, 0, &value);
|
|
value = value & 0x0F;
|
|
if (status == 0) {
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
outb(value, RXLOS_MSK);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
status = size;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static ssize_t fan_led_show(struct device *dev, struct device_attribute *devattr,
|
|
char *buf)
|
|
{
|
|
struct sensor_device_attribute *sa = to_sensor_dev_attr(devattr);
|
|
int index = sa->index;
|
|
unsigned char data = 0;
|
|
char *led_str[5] = {"green", "green-blink", "amber", "amber-blink", "off"};
|
|
|
|
// Use index to determind the status bit
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
data = inb(FAN_LED_1 + index);
|
|
data = data & 0x7;
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return sprintf(buf, "%s\n", led_str[data]);
|
|
}
|
|
|
|
static ssize_t fan_led_store(struct device *dev, struct device_attribute *devattr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct sensor_device_attribute *sa = to_sensor_dev_attr(devattr);
|
|
int index = sa->index;
|
|
unsigned char led_status = 0;
|
|
|
|
if (sysfs_streq(buf, "off")) {
|
|
led_status = fan_led_off;
|
|
} else if (sysfs_streq(buf, "green")) {
|
|
led_status = fan_led_grn;
|
|
} else if (sysfs_streq(buf, "amber")) {
|
|
led_status = fan_led_amb;
|
|
} else if (sysfs_streq(buf, "green-blink")) {
|
|
led_status = fan_led_grn_bnk;
|
|
} else if (sysfs_streq(buf, "amber-blink")) {
|
|
led_status = fan_led_amb_bnk;
|
|
} else {
|
|
count = -EINVAL;
|
|
return count;
|
|
}
|
|
mutex_lock(&cpld_data->cpld_lock);
|
|
outb(led_status, FAN_LED_1 + index);
|
|
mutex_unlock(&cpld_data->cpld_lock);
|
|
return count;
|
|
}
|
|
|
|
static DEVICE_ATTR_RO(version);
|
|
static DEVICE_ATTR_RW(scratch);
|
|
static DEVICE_ATTR_RW(getreg);
|
|
static DEVICE_ATTR_WO(setreg);
|
|
static DEVICE_ATTR_RW(status_led);
|
|
static DEVICE_ATTR_RW(master_led);
|
|
static DEVICE_ATTR_RO(psuL_prs);
|
|
static DEVICE_ATTR_RO(psuL_status);
|
|
static DEVICE_ATTR_RO(psuR_status);
|
|
static DEVICE_ATTR_RO(sfp_txfault);
|
|
static DEVICE_ATTR_RO(sfp_modabs);
|
|
static DEVICE_ATTR_RO(sfp_rxlos);
|
|
static DEVICE_ATTR_RW(sfp_txdis);
|
|
static DEVICE_ATTR_RW(sfp_rs);
|
|
static DEVICE_ATTR_RW(txfault_trig);
|
|
static DEVICE_ATTR_RW(modabs_trig);
|
|
static DEVICE_ATTR_RW(rxlos_trig);
|
|
static DEVICE_ATTR_RO(txfault_int);
|
|
static DEVICE_ATTR_RO(modabs_int);
|
|
static DEVICE_ATTR_RO(rxlos_int);
|
|
static DEVICE_ATTR_RW(txfault_mask);
|
|
static DEVICE_ATTR_RW(modabs_mask);
|
|
static DEVICE_ATTR_RW(rxlos_mask);
|
|
static SENSOR_DEVICE_ATTR(fan1_dir, S_IRUGO, fan_dir_show, NULL, FAN_1);
|
|
static SENSOR_DEVICE_ATTR(fan2_dir, S_IRUGO, fan_dir_show, NULL, FAN_2);
|
|
static SENSOR_DEVICE_ATTR(fan3_dir, S_IRUGO, fan_dir_show, NULL, FAN_3);
|
|
static SENSOR_DEVICE_ATTR(fan1_led, S_IWUSR | S_IRUGO, fan_led_show, fan_led_store, FAN_1);
|
|
static SENSOR_DEVICE_ATTR(fan2_led, S_IWUSR | S_IRUGO, fan_led_show, fan_led_store, FAN_2);
|
|
static SENSOR_DEVICE_ATTR(fan3_led, S_IWUSR | S_IRUGO, fan_led_show, fan_led_store, FAN_3);
|
|
static SENSOR_DEVICE_ATTR(fan1_prs, S_IRUGO, fan_prs_show, NULL, FAN1_PRS);
|
|
static SENSOR_DEVICE_ATTR(fan2_prs, S_IRUGO, fan_prs_show, NULL, FAN2_PRS);
|
|
static SENSOR_DEVICE_ATTR(fan3_prs, S_IRUGO, fan_prs_show, NULL, FAN3_PRS);
|
|
|
|
static struct attribute *cpld_attrs[] = {
|
|
&dev_attr_version.attr,
|
|
&dev_attr_scratch.attr,
|
|
&dev_attr_getreg.attr,
|
|
&dev_attr_setreg.attr,
|
|
// LEDs
|
|
&dev_attr_status_led.attr,
|
|
&dev_attr_master_led.attr,
|
|
// PSUs
|
|
&dev_attr_psuL_prs.attr,
|
|
&dev_attr_psuR_prs.attr,
|
|
&dev_attr_psuL_status.attr,
|
|
&dev_attr_psuR_status.attr,
|
|
// FANs
|
|
&sensor_dev_attr_fan1_dir.dev_attr.attr,
|
|
&sensor_dev_attr_fan2_dir.dev_attr.attr,
|
|
&sensor_dev_attr_fan3_dir.dev_attr.attr,
|
|
&sensor_dev_attr_fan1_led.dev_attr.attr,
|
|
&sensor_dev_attr_fan2_led.dev_attr.attr,
|
|
&sensor_dev_attr_fan3_led.dev_attr.attr,
|
|
&sensor_dev_attr_fan1_prs.dev_attr.attr,
|
|
&sensor_dev_attr_fan2_prs.dev_attr.attr,
|
|
&sensor_dev_attr_fan3_prs.dev_attr.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group cpld_group = {
|
|
.attrs = cpld_attrs,
|
|
};
|
|
|
|
static struct attribute *sfp_attrs[] = {
|
|
// SFP
|
|
&dev_attr_sfp_txfault.attr,
|
|
&dev_attr_sfp_modabs.attr,
|
|
&dev_attr_sfp_rxlos.attr,
|
|
&dev_attr_sfp_txdis.attr,
|
|
&dev_attr_sfp_rs.attr,
|
|
&dev_attr_txfault_trig.attr,
|
|
&dev_attr_modabs_trig.attr,
|
|
&dev_attr_rxlos_trig.attr,
|
|
&dev_attr_txfault_int.attr,
|
|
&dev_attr_modabs_int.attr,
|
|
&dev_attr_rxlos_int.attr,
|
|
&dev_attr_txfault_mask.attr,
|
|
&dev_attr_modabs_mask.attr,
|
|
&dev_attr_rxlos_mask.attr,
|
|
NULL,
|
|
};
|
|
|
|
ATTRIBUTE_GROUPS(sfp);
|
|
|
|
static struct resource cpld_resources[] = {
|
|
{
|
|
.start = 0x0200,
|
|
.end = 0x0255,
|
|
.flags = IORESOURCE_IO,
|
|
},
|
|
};
|
|
|
|
static void cpld_dev_release( struct device * dev)
|
|
{
|
|
return;
|
|
}
|
|
|
|
static struct platform_device cpld_dev = {
|
|
.name = DRIVER_NAME,
|
|
.id = -1,
|
|
.num_resources = ARRAY_SIZE(cpld_resources),
|
|
.resource = cpld_resources,
|
|
.dev = {
|
|
.release = cpld_dev_release,
|
|
}
|
|
};
|
|
|
|
static int cpld_drv_probe(struct platform_device *pdev)
|
|
{
|
|
struct resource *res;
|
|
int err;
|
|
|
|
cpld_data = devm_kzalloc(&pdev->dev, sizeof(struct cpld_data),
|
|
GFP_KERNEL);
|
|
if (!cpld_data)
|
|
return -ENOMEM;
|
|
|
|
mutex_init(&cpld_data->cpld_lock);
|
|
|
|
cpld_data->read_addr = VERSION;
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_IO, 0);
|
|
if (unlikely(!res)) {
|
|
printk(KERN_ERR "Specified Resource Not Available...\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
err = sysfs_create_group(&pdev->dev.kobj, &cpld_group);
|
|
if (err) {
|
|
printk(KERN_ERR "Cannot create sysfs for SMC.\n");
|
|
return err;
|
|
}
|
|
|
|
celplatform = class_create(THIS_MODULE, "celplatform");
|
|
if (IS_ERR(celplatform)) {
|
|
printk(KERN_ERR "Failed to register device class\n");
|
|
sysfs_remove_group(&pdev->dev.kobj, &cpld_group);
|
|
return PTR_ERR(celplatform);
|
|
}
|
|
|
|
cpld_data->fpp_node = device_create_with_groups(celplatform, NULL, MKDEV(0, 0), NULL, sfp_groups, "optical_ports");
|
|
|
|
if (IS_ERR(cpld_data->fpp_node)) {
|
|
class_destroy(celplatform);
|
|
sysfs_remove_group(&pdev->dev.kobj, &cpld_group);
|
|
return PTR_ERR(cpld_data->fpp_node);
|
|
}
|
|
|
|
err = sysfs_create_link(&pdev->dev.kobj, &cpld_data->fpp_node->kobj, "SFP");
|
|
if (err != 0) {
|
|
put_device(cpld_data->fpp_node);
|
|
device_unregister(cpld_data->fpp_node);
|
|
class_destroy(celplatform);
|
|
sysfs_remove_group(&pdev->dev.kobj, &cpld_group);
|
|
return err;
|
|
}
|
|
|
|
// Clear all reset signals
|
|
outb(0xFF, SPR_RESET);
|
|
return 0;
|
|
}
|
|
|
|
static int cpld_drv_remove(struct platform_device *pdev)
|
|
{
|
|
device_unregister(cpld_data->fpp_node);
|
|
put_device(cpld_data->fpp_node);
|
|
sysfs_remove_group(&pdev->dev.kobj, &cpld_group);
|
|
class_destroy(celplatform);
|
|
return 0;
|
|
}
|
|
|
|
static struct platform_driver cpld_drv = {
|
|
.probe = cpld_drv_probe,
|
|
.remove = __exit_p(cpld_drv_remove),
|
|
.driver = {
|
|
.name = DRIVER_NAME,
|
|
},
|
|
};
|
|
|
|
int cpld_init(void)
|
|
{
|
|
// Register platform device and platform driver
|
|
platform_device_register(&cpld_dev);
|
|
platform_driver_register(&cpld_drv);
|
|
return 0;
|
|
}
|
|
|
|
void cpld_exit(void)
|
|
{
|
|
// Unregister platform device and platform driver
|
|
platform_driver_unregister(&cpld_drv);
|
|
platform_device_unregister(&cpld_dev);
|
|
}
|
|
|
|
module_init(cpld_init);
|
|
module_exit(cpld_exit);
|
|
|
|
|
|
MODULE_AUTHOR("Celestica Inc.");
|
|
MODULE_DESCRIPTION("Celestica E1031 SMC driver");
|
|
MODULE_VERSION("1.0.0");
|
|
MODULE_LICENSE("GPL");
|