/*
* Copyright 2019 Broadcom.
* The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
*
* 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.
*
*
* A pddf kernel module to manage various LEDs of a switch
*/
#include <linux/kobject.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/hwmon-sysfs.h>
#include "pddf_led_defs.h"
#include "pddf_client_defs.h"
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#define DEBUG 0
LED_OPS_DATA sys_led_ops_data[1]={0};
LED_OPS_DATA* psu_led_ops_data=NULL;
LED_OPS_DATA diag_led_ops_data[1]= {0};
LED_OPS_DATA fan_led_ops_data[1]= {0};
LED_OPS_DATA loc_led_ops_data[1]= {0};
LED_OPS_DATA* fantray_led_ops_data=NULL;
LED_OPS_DATA temp_data={0};
LED_OPS_DATA* dev_list[LED_TYPE_MAX] = {
sys_led_ops_data,
NULL,
fan_led_ops_data,
NULL,
diag_led_ops_data,
loc_led_ops_data,
};
int num_psus = 0;
int num_fantrays = 0;
extern int board_i2c_cpld_read(unsigned short cpld_addr, u8 reg);
extern int board_i2c_cpld_write(unsigned short cpld_addr, u8 reg, u8 value);
extern ssize_t show_pddf_data(struct device *dev, struct device_attribute *da, char *buf);
extern ssize_t store_pddf_data(struct device *dev, struct device_attribute *da, const char *buf, size_t count);
static LED_STATUS find_state_index(const char* state_str) {
int index;
char *ptr = (char *)state_str;
while (*ptr && *ptr!= '\n' && *ptr !='\0') ptr++;
*ptr='\0';
for ( index = 0; index < MAX_LED_STATUS; index++) {
/*int rc = strcmp(state_str, LED_STATUS_STR[index]) ;*/
if (strcmp(state_str, LED_STATUS_STR[index]) == 0 ) {
return index;
}
}
return MAX_LED_STATUS;
}
static LED_TYPE get_dev_type(char* name)
{
LED_TYPE ret = LED_TYPE_MAX;
if(strcasecmp(name, "SYS_LED")==0) {
ret = LED_SYS;
} else if(strcasecmp(name, "FAN_LED")==0) {
ret = LED_FAN;
} else if(strstr(name, "PSU_LED")) {
ret = LED_PSU;
} else if(strcasecmp(name, "DIAG_LED")==0) {
ret = LED_DIAG;
} else if(strcasecmp(name, "LOC_LED")==0) {
ret = LED_LOC;
} else if(strstr(name, "FANTRAY_LED")) {
ret = LED_FANTRAY;
}
#if DEBUG > 1
pddf_dbg(LED, KERN_INFO "LED get_dev_type: %s; %d\n", name, ret);
#endif
return (ret);
}
static int dev_index_check(LED_TYPE type, int index)
{
#if DEBUG
pddf_dbg(LED, "dev_index_check: type:%s index:%d num_psus:%d num_fantrays:%d\n",
LED_TYPE_STR[type], index, num_psus, num_fantrays);
#endif
switch(type)
{
case LED_PSU:
if(index >= num_psus) return (-1);
break;
case LED_FANTRAY:
if(index >= num_fantrays) return (-1);
break;
default:
if(index >= 1) return (-1);
break;
}
return (0);
}
static LED_OPS_DATA* find_led_ops_data(struct device_attribute *da)
{
struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da;
LED_OPS_DATA* ptr=(LED_OPS_DATA*)_ptr->addr;
LED_TYPE led_type;
if(!ptr || strlen(ptr->device_name)==0 ) return(NULL);
if((led_type=get_dev_type(ptr->device_name))==LED_TYPE_MAX) {
printk(KERN_ERR "PDDF_LED ERROR *%s Unsupported Led Type\n", __func__);
return(NULL);
}
if(dev_index_check(led_type, ptr->index)==-1) {
printk(KERN_ERR "PDDF_LED ERROR %s invalid index: %d for type:%s\n", __func__, ptr->index, ptr->device_name);
return(NULL);
}
#if DEBUG > 1
pddf_dbg(LED, "find_led_ops_data: name:%s; index=%d tempAddr:%p actualAddr:%p\n",
ptr->device_name, ptr->index, ptr, dev_list[led_type]+ptr->index);
#endif
return (dev_list[led_type]+ptr->index);
}
static void print_led_data(LED_OPS_DATA *ptr, LED_STATUS state)
{
int i = 0;
if(!ptr) return ;
pddf_dbg(LED, KERN_INFO "Print %s index:%d num_psus:%d num_fantrays:%d ADDR=%p\n",
ptr->device_name, ptr->index, num_psus, num_fantrays, ptr);
pddf_dbg(LED, KERN_INFO "\tindex: %d\n", ptr->index);
pddf_dbg(LED, KERN_INFO "\tcur_state: %d; %s \n", ptr->cur_state.state, ptr->cur_state.color);
for (i = 0; i< MAX_LED_STATUS; i++) {
if(ptr->data[i].swpld_addr && (i == state || state == -1)) {
pddf_dbg(LED, KERN_INFO "\t\t[%s]: addr/offset:0x%x;0x%x color:%s; value:%x; mask_bits: 0x%x; pos:%d\n",
LED_STATUS_STR[i],
ptr->data[i].swpld_addr, ptr->data[i].swpld_addr_offset,
LED_STATUS_STR[i], ptr->data[i].value, ptr->data[i].bits.mask_bits, ptr->data[i].bits.pos);
}
}
}
ssize_t get_status_led(struct device_attribute *da)
{
int ret=0;
struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da;
LED_OPS_DATA* temp_data_ptr=(LED_OPS_DATA*)_ptr->addr;
LED_OPS_DATA* ops_ptr=find_led_ops_data(da);
uint32_t color_val=0, sys_val=0;
int state=0;
if (!ops_ptr) {
pddf_dbg(LED, KERN_ERR "ERROR %s: Cannot find LED Ptr", __func__);
return (-1);
}
if (ops_ptr->swpld_addr == 0x0) {
pddf_dbg(LED, KERN_ERR "ERROR %s: device: %s %d not configured\n", __func__,
temp_data_ptr->device_name, temp_data_ptr->index);
return (-1);
}
sys_val = board_i2c_cpld_read(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset);
if (sys_val < 0)
return sys_val;
strcpy(temp_data.cur_state.color, "None");
for (state=0; state<MAX_LED_STATUS; state++) {
color_val = (sys_val & ~ops_ptr->data[state].bits.mask_bits);
if ((color_val ^ (ops_ptr->data[state].value<<ops_ptr->data[state].bits.pos))==0) {
strcpy(temp_data.cur_state.color, LED_STATUS_STR[state]);
}
}
#if DEBUG > 1
pddf_dbg(LED, KERN_ERR "Get : %s:%d addr/offset:0x%x; 0x%x value=0x%x [%s]\n",
ops_ptr->device_name, ops_ptr->index,
ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset, sys_val,
temp_data.cur_state.color);
#endif
return(ret);
}
ssize_t set_status_led(struct device_attribute *da)
{
int ret=0;
uint32_t sys_val=0, new_val=0;
LED_STATUS cur_state = MAX_LED_STATUS;
struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da;
LED_OPS_DATA* temp_data_ptr=(LED_OPS_DATA*)_ptr->addr;
LED_OPS_DATA* ops_ptr=find_led_ops_data(da);
char* _buf=temp_data_ptr->cur_state.color;
if (!ops_ptr) {
pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR %s: Cannot find LED Ptr", __func__);
return (-1);
}
if (ops_ptr->swpld_addr == 0x0) {
pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR %s: device: %s %d not configured\n",
__func__, ops_ptr->device_name, ops_ptr->index);
return (-1);
}
pddf_dbg(LED, KERN_ERR "%s: Set [%s;%d] color[%s]\n", __func__,
temp_data_ptr->device_name, temp_data_ptr->index,
temp_data_ptr->cur_state.color);
cur_state = find_state_index(_buf);
if (cur_state == MAX_LED_STATUS) {
pddf_dbg(LED, KERN_ERR "ERROR %s: not supported: %s\n", _buf, __func__);
return (-1);
}
if(ops_ptr->data[cur_state].swpld_addr != 0x0) {
sys_val = board_i2c_cpld_read(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset);
if (sys_val < 0)
return sys_val;
new_val = (sys_val & ops_ptr->data[cur_state].bits.mask_bits) |
(ops_ptr->data[cur_state].value << ops_ptr->data[cur_state].bits.pos);
} else {
pddf_dbg(LED, KERN_ERR "ERROR %s: %s %d state %d; %s not configured\n",__func__,
ops_ptr->device_name, ops_ptr->index, cur_state, _buf);
return (-1);
}
board_i2c_cpld_write(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset, new_val);
pddf_dbg(LED, KERN_INFO "Set color:%s; 0x%x:0x%x sys_val:0x%x new_val:0x%x read:0x%x\n",
LED_STATUS_STR[cur_state],
ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset,
sys_val, new_val,
ret = board_i2c_cpld_read(ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset));
if (ret < 0)
{
pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR %s: Error %d in reading from cpld(0x%x) offset 0x%x\n", __FUNCTION__, ret, ops_ptr->swpld_addr, ops_ptr->swpld_addr_offset);
return ret;
}
return(ret);
}
ssize_t show_pddf_data(struct device *dev, struct device_attribute *da,
char *buf)
{
int ret = 0;
struct pddf_data_attribute *ptr = (struct pddf_data_attribute *)da;
switch(ptr->type)
{
case PDDF_CHAR:
ret = sprintf(buf, "%s\n", ptr->addr);
break;
case PDDF_INT_DEC:
ret = sprintf(buf, "%d\n", *(int*)(ptr->addr));
break;
case PDDF_INT_HEX:
ret = sprintf(buf, "0x%x\n", *(int*)(ptr->addr));
break;
case PDDF_USHORT:
ret = sprintf(buf, "0x%x\n", *(unsigned short *)(ptr->addr));
break;
case PDDF_UINT32:
ret = sprintf(buf, "0x%x\n", *(uint32_t *)(ptr->addr));
break;
default:
break;
}
#if DEBUG > 1
pddf_dbg(LED, "[ READ ] DATA ATTR PTR [%s] TYPE:%d, Value:[%s]\n",
ptr->dev_attr.attr.name, ptr->type, buf);
#endif
return ret;
}
ssize_t store_pddf_data(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
int ret = 0, num = 0;
struct pddf_data_attribute *ptr = (struct pddf_data_attribute *)da;
switch(ptr->type)
{
case PDDF_CHAR:
strncpy(ptr->addr, buf, strlen(buf)-1); // to discard newline char form buf
ptr->addr[strlen(buf)-1] = '\0';
#if DEBUG
pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_CHAR VALUE:%s\n",
ptr->dev_attr.attr.name, ptr->addr);
#endif
break;
case PDDF_INT_DEC:
ret = kstrtoint(buf,10,&num);
if (ret==0)
*(int *)(ptr->addr) = num;
#if DEBUG
pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_DEC VALUE:%d\n",
ptr->dev_attr.attr.name, *(int *)(ptr->addr));
#endif
break;
case PDDF_INT_HEX:
ret = kstrtoint(buf,16,&num);
if (ret==0)
*(int *)(ptr->addr) = num;
#if DEBUG
pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_HEX VALUE:0x%x\n",
ptr->dev_attr.attr.name, *(int *)(ptr->addr));
#endif
break;
case PDDF_USHORT:
ret = kstrtoint(buf,16,&num);
if (ret==0)
*(unsigned short *)(ptr->addr) = (unsigned short)num;
#if DEBUG
pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_USHORT VALUE:%x\n",
ptr->dev_attr.attr.name, *(unsigned short *)(ptr->addr));
#endif
break;
case PDDF_UINT32:
ret = kstrtoint(buf,16,&num);
if (ret==0)
*(uint32_t *)(ptr->addr) = (uint32_t)num;
#if DEBUG
pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR [%s] PDDF_UINT32 VALUE:%d\n",
ptr->dev_attr.attr.name, *(uint32_t *)(ptr->addr));
#endif
break;
default:
break;
}
return count;
}
static int load_led_ops_data(struct device_attribute *da, LED_STATUS state)
{
struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da;
LED_OPS_DATA* ptr=(LED_OPS_DATA*)_ptr->addr;
LED_TYPE led_type;
LED_OPS_DATA* ops_ptr=NULL;
if(!ptr || strlen(ptr->device_name)==0 ) {
pddf_dbg(LED, KERN_INFO "SYSTEM_LED: load_led_ops_data return -1 device_name:%s\n", ptr? ptr->device_name:"NULL");
return(-1);
}
if(ptr->device_name)
{
pddf_dbg(LED, KERN_INFO "[%s]: load_led_ops_data: index=%d addr=0x%x;0x%x valu=0x%x\n",
ptr->device_name, ptr->index, ptr->swpld_addr, ptr->swpld_addr_offset, ptr->data[0].value);
}
if((led_type=get_dev_type(ptr->device_name))==LED_TYPE_MAX) {
pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR *%s Unsupported Led Type\n", __func__);
return(-1);
}
if(dev_index_check(led_type, ptr->index)==-1) {
pddf_dbg(LED, KERN_ERR "PDDF_LED ERROR %s invalid index: %d for type:%d\n", __func__, ptr->index, led_type);
return(-1);
}
ops_ptr = dev_list[led_type]+ptr->index;
memcpy(ops_ptr->device_name, ptr->device_name, sizeof(ops_ptr->device_name));
ops_ptr->index = ptr->index;
memcpy(&ops_ptr->data[state], &ptr->data[0], sizeof(LED_DATA));
ops_ptr->data[state].swpld_addr = ptr->swpld_addr;
ops_ptr->data[state].swpld_addr_offset = ptr->swpld_addr_offset;
ops_ptr->swpld_addr = ptr->swpld_addr;
ops_ptr->swpld_addr_offset = ptr->swpld_addr_offset;
print_led_data(dev_list[led_type]+ptr->index, state);
memset(ptr, 0, sizeof(LED_OPS_DATA));
return (0);
}
static int show_led_ops_data(struct device_attribute *da)
{
LED_OPS_DATA* ops_ptr=find_led_ops_data(da);
print_led_data(ops_ptr, -1);
return(0);
}
static int verify_led_ops_data(struct device_attribute *da)
{
struct pddf_data_attribute *_ptr = (struct pddf_data_attribute *)da;
LED_OPS_DATA* ptr=(LED_OPS_DATA*)_ptr->addr;
LED_OPS_DATA* ops_ptr=find_led_ops_data(da);
if(ops_ptr)
memcpy(ptr, ops_ptr, sizeof(LED_OPS_DATA));
else
{
pddf_dbg(LED, "SYSTEM_LED: verify_led_ops_data: Failed to find ops_ptr name:%s; index=%d\n", ptr->device_name, ptr->index);
}
return (0);
}
ssize_t dev_operation(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
#if DEBUG
pddf_dbg(LED, KERN_INFO "dev_operation [%s]\n", buf);
#endif
if(strstr(buf, "STATUS_LED_COLOR")!= NULL) {
LED_STATUS index = find_state_index(buf);
if (index < MAX_LED_STATUS ) {
load_led_ops_data(da, index);
} else {
printk(KERN_ERR "PDDF_ERROR %s: Invalid state for dev_ops %s", __FUNCTION__, buf);
}
}
else if(strncmp(buf, "show", strlen("show"))==0 ) {
show_led_ops_data(da);
}
else if(strncmp(buf, "verify", strlen("verify"))==0 ) {
verify_led_ops_data(da);
}
else if(strncmp(buf, "get_status", strlen("get_status"))==0 ) {
get_status_led(da);
}
else if(strncmp(buf, "set_status", strlen("set_status"))==0 ) {
set_status_led(da);
}
else {
printk(KERN_ERR "PDDF_ERROR %s: Invalid value for dev_ops %s", __FUNCTION__, buf);
}
return(count);
}
ssize_t store_config_data(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
int ret, num;
struct pddf_data_attribute *ptr = (struct pddf_data_attribute *)da;
if(strncmp(ptr->dev_attr.attr.name, "num_psus", strlen("num_psus"))==0 ) {
ret = kstrtoint(buf,10,&num);
if (ret==0)
*(int *)(ptr->addr) = num;
if(psu_led_ops_data == NULL) {
if ((psu_led_ops_data = kzalloc(num * sizeof(LED_OPS_DATA), GFP_KERNEL)) == NULL) {
printk(KERN_ERR "PDDF_LED ERROR failed to allocate memory for PSU LED\n");
return (count);
}
pddf_dbg(LED, "Allocate PSU LED Memory ADDR=%p\n", psu_led_ops_data);
dev_list[LED_PSU]=psu_led_ops_data;
}
#if DEBUG
pddf_dbg(LED, "[ WRITE ] ATTR CONFIG [%s] VALUE:%d; %d\n",
ptr->dev_attr.attr.name, num, num_psus);
#endif
return(count);
}
if(strncmp(ptr->dev_attr.attr.name, "num_fantrays", strlen("num_fantrays"))==0 ) {
ret = kstrtoint(buf,10,&num);
if (ret==0)
*(int *)(ptr->addr) = num;
if (fantray_led_ops_data == NULL) {
if ((fantray_led_ops_data = kzalloc(num * sizeof(LED_OPS_DATA), GFP_KERNEL)) == NULL) {
printk(KERN_ERR "PDDF_LED ERROR failed to allocate memory for FANTRAY LED\n");
return (count);
}
pddf_dbg(LED, "Allocate FanTray LED Memory ADDR=%p\n", fantray_led_ops_data);
dev_list[LED_FANTRAY]=fantray_led_ops_data;
}
#if DEBUG
pddf_dbg(LED, "[ WRITE ] ATTR CONFIG [%s] VALUE:%d; %d\n",
ptr->dev_attr.attr.name, num, num_fantrays);
#endif
return(count);
}
return (count);
}
ssize_t store_bits_data(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
int len = 0, num1 = 0, num2 = 0, i=0, rc1=0, rc2=0;
char mask=0xFF;
char *pptr=NULL;
char bits[NAME_SIZE];
struct pddf_data_attribute *ptr = (struct pddf_data_attribute *)da;
MASK_BITS* bits_ptr=(MASK_BITS*)(ptr->addr);
strncpy(bits_ptr->bits, buf, strlen(buf)-1); // to discard newline char form buf
bits_ptr->bits[strlen(buf)-1] = '\0';
if((pptr=strstr(buf,":")) != NULL) {
len=pptr-buf;
sprintf(bits, buf);
bits[len]='\0';
rc1=kstrtoint(bits,16,&num1);
if (rc1==0)
{
sprintf(bits, ++pptr);
rc2=kstrtoint(bits,16,&num2);
if (rc2==0)
{
for (i=num2; i<=num1; i++) {
mask &= ~(1 << i);
}
bits_ptr->mask_bits = mask;
bits_ptr->pos = num2;
}
}
} else {
rc1=kstrtoint(buf,16,&num1);
if (rc1==0)
{
bits_ptr->mask_bits = mask & ~(1 << num1);
bits_ptr->pos = num1;
}
}
#if DEBUG
pddf_dbg(LED, KERN_ERR "[ WRITE ] ATTR PTR Bits [%s] VALUE:%s mask:0x%x; pos:0x%x\n",
ptr->dev_attr.attr.name, bits_ptr->bits, bits_ptr->mask_bits, bits_ptr->pos);
#endif
return (count);
}
/**************************************************************************
* platform/ attributes
**************************************************************************/
PDDF_LED_DATA_ATTR(platform, num_psus, S_IWUSR|S_IRUGO, show_pddf_data,
store_config_data, PDDF_INT_DEC, sizeof(int), (void*)&num_psus);
PDDF_LED_DATA_ATTR(platform, num_fantrays, S_IWUSR|S_IRUGO, show_pddf_data,
store_config_data, PDDF_INT_DEC, sizeof(int), (void*)&num_fantrays);
struct attribute* attrs_platform[]={
&pddf_dev_platform_attr_num_psus.dev_attr.attr,
&pddf_dev_platform_attr_num_fantrays.dev_attr.attr,
NULL,
};
struct attribute_group attr_group_platform={
.attrs = attrs_platform,
};
/**************************************************************************
* led/ attributes
**************************************************************************/
PDDF_LED_DATA_ATTR(dev, device_name, S_IWUSR|S_IRUGO, show_pddf_data,
store_pddf_data, PDDF_CHAR, NAME_SIZE, (void*)&temp_data.device_name);
PDDF_LED_DATA_ATTR(dev, index, S_IWUSR|S_IRUGO, show_pddf_data,
store_pddf_data, PDDF_INT_DEC, sizeof(int), (void*)&temp_data.index);
PDDF_LED_DATA_ATTR(dev, swpld_addr, S_IWUSR|S_IRUGO, show_pddf_data,
store_pddf_data, PDDF_INT_HEX, sizeof(int), (void*)&temp_data.swpld_addr);
PDDF_LED_DATA_ATTR(dev, swpld_addr_offset, S_IWUSR|S_IRUGO, show_pddf_data,
store_pddf_data, PDDF_INT_HEX, sizeof(int), (void*)&temp_data.swpld_addr_offset);
PDDF_LED_DATA_ATTR(dev, dev_ops , S_IWUSR, NULL,
dev_operation, PDDF_CHAR, NAME_SIZE, (void*)&temp_data);
struct attribute* attrs_dev[]={
&pddf_dev_dev_attr_device_name.dev_attr.attr,
&pddf_dev_dev_attr_index.dev_attr.attr,
&pddf_dev_dev_attr_swpld_addr.dev_attr.attr,
&pddf_dev_dev_attr_swpld_addr_offset.dev_attr.attr,
&pddf_dev_dev_attr_dev_ops.dev_attr.attr,
NULL,
};
struct attribute_group attr_group_dev={
.attrs = attrs_dev,
};
/**************************************************************************
* state_attr/ attributes
**************************************************************************/
#define LED_DEV_STATE_ATTR_GROUP(name, func) \
PDDF_LED_DATA_ATTR(name, bits, S_IWUSR|S_IRUGO, show_pddf_data, \
store_bits_data, PDDF_CHAR, NAME_SIZE, func.bits.bits); \
PDDF_LED_DATA_ATTR(name, value, S_IWUSR|S_IRUGO, show_pddf_data, \
store_pddf_data, PDDF_USHORT, sizeof(unsigned short), func.value); \
struct attribute* attrs_##name[]={ \
&pddf_dev_##name##_attr_bits.dev_attr.attr, \
&pddf_dev_##name##_attr_value.dev_attr.attr, \
NULL, \
}; \
struct attribute_group attr_group_##name={ \
.attrs = attrs_##name, \
}; \
LED_DEV_STATE_ATTR_GROUP(state_attr, (void*)&temp_data.data[0])
/**************************************************************************
* cur_state/ attributes
**************************************************************************/
PDDF_LED_DATA_ATTR(cur_state, color, S_IWUSR|S_IRUGO, show_pddf_data,
store_pddf_data, PDDF_CHAR, NAME_SIZE, (void*)&temp_data.cur_state.color);
struct attribute* attrs_cur_state[]={
&pddf_dev_cur_state_attr_color.dev_attr.attr,
NULL,
};
struct attribute_group attr_group_cur_state={
.attrs = attrs_cur_state,
};
/*************************************************************************/
#define KOBJ_FREE(obj) \
if(obj) kobject_put(obj); \
void free_kobjs(void)
{
KOBJ_FREE(cur_state_kobj)
KOBJ_FREE(state_attr_kobj)
KOBJ_FREE(led_kobj)
KOBJ_FREE(platform_kobj)
}
int KBOJ_CREATE(char* name, struct kobject* parent, struct kobject** child)
{
if (parent) {
*child = kobject_create_and_add(name, parent);
} else {
printk(KERN_ERR "PDDF_LED ERROR to create %s kobj; null parent\n", name);
free_kobjs();
return (-ENOMEM);
}
return (0);
}
int LED_DEV_ATTR_CREATE(struct kobject *kobj, const struct attribute_group *attr, const char* name)
{
int status = sysfs_create_group(kobj, attr);
if(status) {
pddf_dbg(LED, KERN_ERR "Driver ERROR: sysfs_create %s failed rc=%d\n", name, status);
}
return (status);
}
static int __init led_init(void) {
struct kobject *device_kobj;
pddf_dbg(LED, KERN_INFO "PDDF GENERIC LED MODULE init..\n");
device_kobj = get_device_i2c_kobj();
if(!device_kobj)
return -ENOMEM;
KBOJ_CREATE("platform", device_kobj, &platform_kobj);
KBOJ_CREATE("led", device_kobj, &led_kobj);
KBOJ_CREATE("state_attr", led_kobj, &state_attr_kobj);
KBOJ_CREATE("cur_state", led_kobj, &cur_state_kobj);
LED_DEV_ATTR_CREATE(platform_kobj, &attr_group_platform, "attr_group_platform");
LED_DEV_ATTR_CREATE(led_kobj, &attr_group_dev, "attr_group_dev");
LED_DEV_ATTR_CREATE(state_attr_kobj, &attr_group_state_attr, "attr_group_state_attr");
LED_DEV_ATTR_CREATE(cur_state_kobj, &attr_group_cur_state, "attr_group_cur_state");
return (0);
}
static void __exit led_exit(void) {
pddf_dbg(LED, "PDDF GENERIC LED MODULE exit..\n");
free_kobjs();
if(psu_led_ops_data) kfree(psu_led_ops_data);
if(fantray_led_ops_data) kfree(fantray_led_ops_data);
}
module_init(led_init);
module_exit(led_exit);
MODULE_AUTHOR("Broadcom");
MODULE_DESCRIPTION("led driver");
MODULE_LICENSE("GPL");