Changeset 12096


Ignore:
Timestamp:
2008-08-04T17:51:47+02:00 (10 years ago)
Author:
blogic
Message:

more ledtrig-netdev clean ups

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/generic-2.6/files-2.6.26/drivers/leds/ledtrig-netdev.c

    r11155 r12096  
    2828#include <linux/ctype.h> 
    2929#include <linux/leds.h> 
     30#include <linux/version.h> 
     31 
     32#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26) 
     33#include <net/net_namespace.h> 
     34#endif 
     35 
    3036#include "leds.h" 
    3137 
     
    7076struct led_netdev_data { 
    7177        rwlock_t lock; 
    72          
     78 
    7379        struct timer_list timer; 
    74         struct notifier_block notifier;  
    75          
     80        struct notifier_block notifier; 
     81 
    7682        struct led_classdev *led_cdev; 
    7783        struct net_device *net_dev; 
    78          
     84 
    7985        char device_name[IFNAMSIZ]; 
    8086        unsigned interval; 
     
    8591 
    8692static void set_baseline_state(struct led_netdev_data *trigger_data) 
    87 {   
     93{ 
    8894        if ((trigger_data->mode & MODE_LINK) != 0 && trigger_data->link_up) 
    8995                led_set_brightness(trigger_data->led_cdev, LED_FULL); 
    9096        else 
    9197                led_set_brightness(trigger_data->led_cdev, LED_OFF); 
    92          
     98 
    9399        if ((trigger_data->mode & (MODE_TX | MODE_RX)) != 0 && trigger_data->link_up) 
    94100                mod_timer(&trigger_data->timer, jiffies + trigger_data->interval); 
    95101        else 
    96                 del_timer(&trigger_data->timer);     
    97 }   
     102                del_timer(&trigger_data->timer); 
     103} 
    98104 
    99105static ssize_t led_device_name_show(struct device *dev, 
     
    102108        struct led_classdev *led_cdev = dev_get_drvdata(dev); 
    103109        struct led_netdev_data *trigger_data = led_cdev->trigger_data; 
    104          
     110 
    105111        read_lock(&trigger_data->lock); 
    106112        sprintf(buf, "%s\n", trigger_data->device_name); 
    107113        read_unlock(&trigger_data->lock); 
    108          
     114 
    109115        return strlen(buf) + 1; 
    110116} 
    111    
    112 static ssize_t led_device_name_store(struct device *dev,  
     117 
     118#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21) 
     119extern struct net init_net; 
     120#endif 
     121 
     122static ssize_t led_device_name_store(struct device *dev, 
    113123                                     struct device_attribute *attr, const char *buf, size_t size) 
    114124{ 
    115125        struct led_classdev *led_cdev = dev_get_drvdata(dev); 
    116126        struct led_netdev_data *trigger_data = led_cdev->trigger_data; 
    117          
     127 
    118128        if (size < 0 || size >= IFNAMSIZ) 
    119129                return -EINVAL; 
    120          
     130 
    121131        write_lock(&trigger_data->lock); 
    122132 
     
    124134        if (size > 0 && trigger_data->device_name[size-1] == '\n') 
    125135                trigger_data->device_name[size-1] = 0; 
    126          
     136 
    127137        if (trigger_data->device_name[0] != 0) { 
    128138                /* check for existing device to update from */ 
     139#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26) 
     140                trigger_data->net_dev = dev_get_by_name(&init_net, trigger_data->device_name); 
     141#else 
    129142                trigger_data->net_dev = dev_get_by_name(trigger_data->device_name); 
     143#endif 
    130144                if (trigger_data->net_dev != NULL) 
    131145                        trigger_data->link_up = (dev_get_flags(trigger_data->net_dev) & IFF_LOWER_UP) != 0; 
    132146                set_baseline_state(trigger_data); /* updates LEDs, may start timers */ 
    133147        } 
    134          
    135         write_unlock(&trigger_data->lock);       
     148 
     149        write_unlock(&trigger_data->lock); 
    136150        return size; 
    137151} 
     
    144158        struct led_classdev *led_cdev = dev_get_drvdata(dev); 
    145159        struct led_netdev_data *trigger_data = led_cdev->trigger_data; 
    146          
     160 
    147161        read_lock(&trigger_data->lock); 
    148          
     162 
    149163        if (trigger_data->mode == 0) { 
    150164                strcpy(buf, "none\n"); 
    151165        } else { 
    152                 if (trigger_data->mode & MODE_LINK)  
     166                if (trigger_data->mode & MODE_LINK) 
    153167                        strcat(buf, "link "); 
    154168                if (trigger_data->mode & MODE_TX) 
     
    158172                strcat(buf, "\n"); 
    159173        } 
    160          
    161         read_unlock(&trigger_data->lock);        
     174 
     175        read_unlock(&trigger_data->lock); 
    162176 
    163177        return strlen(buf)+1; 
    164178} 
    165179 
    166 static ssize_t led_mode_store(struct device *dev,  
     180static ssize_t led_mode_store(struct device *dev, 
    167181                              struct device_attribute *attr, const char *buf, size_t size) 
    168182{ 
    169183        struct led_classdev *led_cdev = dev_get_drvdata(dev); 
    170         struct led_netdev_data *trigger_data = led_cdev->trigger_data;   
     184        struct led_netdev_data *trigger_data = led_cdev->trigger_data; 
    171185        char copybuf[1024]; 
    172186        int new_mode = -1; 
     
    177191        copybuf[1023] = 0; 
    178192        p = copybuf; 
    179          
     193 
    180194        while ((token = strsep(&p, " \t\n")) != NULL) { 
    181195                if (!*token) 
    182196                        continue; 
    183                  
     197 
    184198                if (new_mode == -1) 
    185199                        new_mode = 0; 
    186                  
     200 
    187201                if (!strcmp(token, "none")) 
    188202                        new_mode = 0; 
     
    196210                        return -EINVAL; 
    197211        } 
    198          
     212 
    199213        if (new_mode == -1) 
    200214                return -EINVAL; 
    201          
    202         write_lock(&trigger_data->lock);         
    203         trigger_data->mode = new_mode;   
     215 
     216        write_lock(&trigger_data->lock); 
     217        trigger_data->mode = new_mode; 
    204218        set_baseline_state(trigger_data); 
    205219        write_unlock(&trigger_data->lock); 
    206          
     220 
    207221        return size; 
    208222} 
     
    210224static DEVICE_ATTR(mode, 0644, led_mode_show, led_mode_store); 
    211225 
    212 static ssize_t led_interval_show(struct device *dev,  
     226static ssize_t led_interval_show(struct device *dev, 
    213227                                 struct device_attribute *attr, char *buf) 
    214228{ 
    215229        struct led_classdev *led_cdev = dev_get_drvdata(dev); 
    216230        struct led_netdev_data *trigger_data = led_cdev->trigger_data; 
    217          
     231 
    218232        read_lock(&trigger_data->lock); 
    219233        sprintf(buf, "%u\n", jiffies_to_msecs(trigger_data->interval)); 
    220234        read_unlock(&trigger_data->lock); 
    221          
     235 
    222236        return strlen(buf) + 1; 
    223237} 
    224238 
    225 static ssize_t led_interval_store(struct device *dev,  
     239static ssize_t led_interval_store(struct device *dev, 
    226240                                  struct device_attribute *attr, const char *buf, size_t size) 
    227241{ 
     
    244258                ret = count; 
    245259        } 
    246          
     260 
    247261        return ret; 
    248262} 
     
    256270        struct net_device *dev = dv; 
    257271        struct led_netdev_data *trigger_data = container_of(nb, struct led_netdev_data, notifier); 
    258          
     272 
    259273        if (evt != NETDEV_UP && evt != NETDEV_DOWN && evt != NETDEV_CHANGE && evt != NETDEV_REGISTER && evt != NETDEV_UNREGISTER) 
    260274                return NOTIFY_DONE; 
    261          
     275 
    262276        write_lock(&trigger_data->lock); 
    263277 
    264278        if (strcmp(dev->name, trigger_data->device_name)) 
    265279                goto done; 
    266          
     280 
    267281        if (evt == NETDEV_REGISTER) { 
    268282                if (trigger_data->net_dev != NULL) 
     
    273287                goto done; 
    274288        } 
    275          
     289 
    276290        if (evt == NETDEV_UNREGISTER && trigger_data->net_dev != NULL) { 
    277291                dev_put(trigger_data->net_dev); 
     
    279293                goto done; 
    280294        } 
    281          
     295 
    282296        /* UP / DOWN / CHANGE */ 
    283          
     297 
    284298        trigger_data->link_up = (evt != NETDEV_DOWN && netif_carrier_ok(dev)); 
    285299        set_baseline_state(trigger_data); 
    286300 
    287301done: 
    288         write_unlock(&trigger_data->lock);   
     302        write_unlock(&trigger_data->lock); 
    289303        return NOTIFY_DONE; 
    290304} 
     
    296310        struct net_device_stats *dev_stats; 
    297311        unsigned new_activity; 
    298          
     312 
    299313        write_lock(&trigger_data->lock); 
    300      
     314 
    301315        if (!trigger_data->link_up || !trigger_data->net_dev || (trigger_data->mode & (MODE_TX | MODE_RX)) == 0) { 
    302316                /* we don't need to do timer work, just reflect link state. */ 
     
    304318                goto no_restart; 
    305319        } 
    306          
     320 
    307321        dev_stats = trigger_data->net_dev->get_stats(trigger_data->net_dev); 
    308322        new_activity = 
    309323                ((trigger_data->mode & MODE_TX) ? dev_stats->tx_packets : 0) + 
    310324                ((trigger_data->mode & MODE_RX) ? dev_stats->rx_packets : 0); 
    311        
     325 
    312326        if (trigger_data->mode & MODE_LINK) { 
    313327                /* base state is ON (link present) */ 
    314328                /* if there's no link, we don't get this far and the LED is off */ 
    315                  
     329 
    316330                /* OFF -> ON always */ 
    317331                /* ON -> OFF on activity */ 
     
    331345                } 
    332346        } 
    333          
     347 
    334348        trigger_data->last_activity = new_activity; 
    335349        mod_timer(&trigger_data->timer, jiffies + trigger_data->interval); 
     
    358372        trigger_data->net_dev = NULL; 
    359373        trigger_data->device_name[0] = 0; 
    360          
     374 
    361375        trigger_data->mode = 0; 
    362376        trigger_data->interval = msecs_to_jiffies(50); 
    363377        trigger_data->link_up = 0; 
    364378        trigger_data->last_activity = 0; 
    365          
     379 
    366380        led_cdev->trigger_data = trigger_data; 
    367381 
     
    376390                goto err_out_mode; 
    377391 
    378         register_netdevice_notifier(&trigger_data->notifier);    
     392        register_netdevice_notifier(&trigger_data->notifier); 
    379393        return; 
    380394 
     
    392406        struct led_netdev_data *trigger_data = led_cdev->trigger_data; 
    393407 
    394         if (trigger_data) {        
     408        if (trigger_data) { 
    395409                unregister_netdevice_notifier(&trigger_data->notifier); 
    396410 
     
    400414 
    401415                write_lock(&trigger_data->lock); 
    402                  
     416 
    403417                if (trigger_data->net_dev) { 
    404418                        dev_put(trigger_data->net_dev); 
    405419                        trigger_data->net_dev = NULL; 
    406420                } 
    407                  
     421 
    408422                write_unlock(&trigger_data->lock); 
    409423 
Note: See TracChangeset for help on using the changeset viewer.