Ticket #9929: dt2_support_fix.patch

File dt2_support_fix.patch, 80.8 KB (added by Zintis Petersons, 6 years ago)

Attachement has Freecom DT2 support fix.

  • files/arch/arm/mach-orion5x/include/mach/dt2-common.h

     
     1#ifndef __INC_DT2_COMMON_H 
     2#define __INC_DT2_COMMON_H 
     3 
     4#define DT2_PIN_GPIO_SYNC               25 
     5#define DT2_PIN_GPIO_POWER              24 
     6#define DT2_PIN_GPIO_UNPLUG1            23 
     7#define DT2_PIN_GPIO_UNPLUG2            22 
     8#define DT2_PIN_GPIO_RESET              4 
     9 
     10#define DT2_LED_POS_SYNC                3 
     11#define DT2_LED_POS_POWER               2 
     12#define DT2_LED_POS_USB1                1 
     13#define DT2_LED_POS_USB2                0 
     14#define DT2_LED_POS_WAN                 5 
     15#define DT2_LED_POS_WLAN                4 
     16#define DT2_LED_POS_SATASW              6 
     17#define DT2_LED_POS_SATAHW              7 
     18 
     19#define DT2_LEDS_BASE                   0xfa000000 
     20#define DT2_LEDS_SIZE                   SZ_1K 
     21 
     22#define ATAG_MV_UBOOT                   0x41000403 
     23 
     24struct tag_mv_uboot { 
     25        u32 uboot_version; 
     26        u32 tclk; 
     27        u32 sysclk; 
     28        u32 isUsbHost; 
     29        u32 overEthAddr; 
     30        u8  dt2_eeprom[256]; 
     31}; 
     32 
     33#define DT2_EEPROM_ADDR                 0x50 
     34#define DT2_EEPROM_OFFSET               0 
     35#define DT2_EEPROM_LENGTH               256 
     36 
     37#define DT2_SERIAL_NUMBER_DEFAULT       "run on default\0" 
     38#define DT2_REVISION_DEFAULT_INIT       0xFF 
     39#define DT2_CONFIG_FLAGS_DEFAULT        0x00 
     40 
     41#define _PACKED_        __attribute__((packed)) 
     42 
     43struct DT2_EEPROM_SD_CONFIG { 
     44        unsigned int    ram_1; 
     45        unsigned int    ram_2; 
     46        unsigned int    ram_3; 
     47        unsigned int    ram_4; 
     48        unsigned char   ram_5; 
     49        unsigned char   ram_6; 
     50        unsigned short  ram_7; 
     51        unsigned int    magic_id; 
     52        } _PACKED_;             // 24 Bytes in total 
     53 
     54struct DT2_EEPROM_FC_CONFIG { 
     55        unsigned char   rtc_sts_mask; 
     56        unsigned char   rtc_sts_init; 
     57        unsigned char   rtc_int_mask; 
     58        unsigned char   rtc_int_init; 
     59        unsigned char   rtc_atrim_init; 
     60        unsigned char   rtc_dtrim_init; 
     61        unsigned char   dummy1; 
     62        unsigned char   dummy2; 
     63        unsigned char   dt2_config_flags;       /* 0x80 to load rtc_values to RTC */ 
     64        unsigned char   dt2_revision;           /* upper nibble is HW, lower nibble is FW */ 
     65        unsigned char   dt2_serial_number[16];  /* Serial number of DT-2 */ 
     66        } _PACKED_;             // 26 Bytes in total 
     67 
     68#define CFG_LOAD_RTC_VALUES     0x80 
     69 
     70struct DT2_EEPROM_GW_CONFIG { 
     71        unsigned int    dummy1; 
     72        unsigned int    dummy2; 
     73        unsigned int    dummy3; 
     74        unsigned char   dummy4; 
     75        unsigned char   tos_video_val1; 
     76        unsigned char   tos_video_val2; 
     77        unsigned char   tos_voip_val; 
     78        unsigned char   qos_igmp_cfg; 
     79        unsigned char   num_of_ifs; 
     80        unsigned short  vlan_ports_if[3]; 
     81        unsigned char   mac_addr[3][6]; 
     82        } _PACKED_;             // 42 Bytes in total 
     83 
     84#define _SIZE_OF_ALL_STRUCTS_ (sizeof(struct DT2_EEPROM_SD_CONFIG) + sizeof(struct DT2_EEPROM_FC_CONFIG) +  sizeof(struct DT2_EEPROM_GW_CONFIG)) 
     85 
     86// MV = EEPROM - SD - FC - GW - CRC 
     87struct DT2_EEPROM_MV_CONFIG { 
     88        unsigned int reg_addr[(DT2_EEPROM_LENGTH - _SIZE_OF_ALL_STRUCTS_ - sizeof(unsigned int)) / (sizeof(unsigned int) * 2)]; 
     89        unsigned int reg_data[(DT2_EEPROM_LENGTH - _SIZE_OF_ALL_STRUCTS_ - sizeof(unsigned int)) / (sizeof(unsigned int) * 2)]; 
     90        } _PACKED_; 
     91 
     92struct DT2_EEPROM_STRUCT { 
     93        struct DT2_EEPROM_MV_CONFIG mv; 
     94        struct DT2_EEPROM_SD_CONFIG sd; 
     95        struct DT2_EEPROM_FC_CONFIG fc; 
     96        struct DT2_EEPROM_GW_CONFIG gw; 
     97        unsigned int    crc; 
     98        } _PACKED_; 
     99 
     100#endif 
  • files/arch/arm/mach-orion5x/dt2-setup.c

    Property changes on: files/arch/arm/mach-orion5x/include/mach/dt2-common.h
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
    1818#include <linux/mtd/physmap.h> 
    1919#include <linux/mv643xx_eth.h> 
    2020#include <linux/ethtool.h> 
    21 #include <linux/if_ether.h> 
     21#include <linux/netdevice.h> 
     22#include <linux/etherdevice.h> 
    2223#include <net/dsa.h> 
    2324#include <linux/ata_platform.h> 
    2425#include <linux/i2c.h> 
     
    3031#include <asm/mach/arch.h> 
    3132#include <asm/mach/pci.h> 
    3233#include <mach/orion5x.h> 
     34#include <asm/setup.h> 
     35#include <mach/dt2-common.h> 
    3336#include "common.h" 
    3437#include "mpp.h" 
    3538 
    3639/***************************************************************************** 
    3740 * DT2 local 
    3841 ****************************************************************************/ 
    39 #include <asm/setup.h> 
    40 #include "dt2-common.h" 
    4142 
    42 u32 mvUbootVer = 0; 
    43 u32 mvTclk = 166666667; 
    44 u32 mvSysclk = 200000000; 
    45 u32 mvIsUsbHost = 1; 
    46 u32 overEthAddr = 0; 
    47 u32 gBoardId = -1; 
    4843struct DT2_EEPROM_STRUCT dt2_eeprom; 
    4944 
    5045/***************************************************************************** 
    5146 * DT2 Info 
    5247 ****************************************************************************/ 
     48 
     49#define DT2_NOR_BOOT_BASE       0xf4000000 
     50#define DT2_NOR_BOOT_SIZE       SZ_512K 
     51 
    5352/* 
    5453 * PCI 
    5554 */ 
     
    5857#define DT2_PCI_SLOT0_IRQ_A_PIN 3 
    5958#define DT2_PCI_SLOT0_IRQ_B_PIN 2 
    6059 
    61 #define DT2_PIN_GPIO_SYNC       25 
    62 #define DT2_PIN_GPIO_POWER      24 
    63 #define DT2_PIN_GPIO_UNPLUG1    23 
    64 #define DT2_PIN_GPIO_UNPLUG2    22 
    65 #define DT2_PIN_GPIO_RESET      4 
    66  
    67 #define DT2_NOR_BOOT_BASE       0xf4000000 
    68 #define DT2_NOR_BOOT_SIZE       SZ_512K 
    69  
    70 #define DT2_LEDS_BASE           0xfa000000 
    71 #define DT2_LEDS_SIZE           SZ_1K 
    72  
    7360/***************************************************************************** 
    7461 * 512K NOR Flash on Device bus Boot CS 
    7562 ****************************************************************************/ 
    7663 
    7764static struct mtd_partition dt2_partitions[] = { 
    7865        { 
    79                 .name   = "u-boot", 
    80                 .size   = 0x00080000, 
    81                 .offset = 0, 
     66                .name           = "U-Boot Config", 
     67                .offset         = 0x00000000, 
     68                /* only the first 4kB is used */ 
     69                .size           = SZ_4K, 
    8270        }, 
    8371}; 
    8472 
     
    10088        .dev            = { 
    10189                .platform_data  = &dt2_nor_flash_data, 
    10290        }, 
    103         .resource       = &dt2_nor_flash_resource, 
    10491        .num_resources  = 1, 
     92        .resource       = &dt2_nor_flash_resource, 
    10593}; 
    10694 
    10795/***************************************************************************** 
    108  * PCI 
     96 * LEDS 
    10997 ****************************************************************************/ 
     98static struct platform_device dt2_leds = { 
     99        .name           = "dt2-led", 
     100        .id             = -1, 
     101}; 
    110102 
     103/***************************************************************************** 
     104 * PCI 
     105 ****************************************************************************/ 
    111106void __init dt2_pci_preinit(void) 
    112107{ 
    113108        int pin, irq; 
     
    120115                if (gpio_direction_input(pin) == 0) { 
    121116                        irq = gpio_to_irq(pin); 
    122117                        irq_set_irq_type(irq, IRQ_TYPE_LEVEL_LOW); 
    123                         printk (KERN_INFO "PCI IntA IRQ: %d\n", irq); 
    124118                } else { 
    125                         printk(KERN_ERR "dt2_pci_preinit failed to " 
    126                                         "irq_set_irq_type pin %d\n", pin); 
     119                        printk(KERN_ERR "%s(%d): failed to " 
     120                                        "irq_set_irq_type pin %d\n", __FUNCTION__, __LINE__, pin); 
    127121                        gpio_free(pin); 
    128122                } 
    129123        } else { 
    130                 printk(KERN_ERR "dt2_pci_preinit failed to request gpio %d\n", pin); 
     124                printk(KERN_ERR "%s(%d): failed to gpio_request %d\n", __FUNCTION__, __LINE__, pin); 
    131125        } 
    132126 
    133127        pin = DT2_PCI_SLOT0_IRQ_B_PIN; 
     
    135129                if (gpio_direction_input(pin) == 0) { 
    136130                        irq = gpio_to_irq(pin); 
    137131                        irq_set_irq_type(irq, IRQ_TYPE_LEVEL_LOW); 
    138                         printk (KERN_INFO "PCI IntB IRQ: %d\n", irq); 
    139132                } else { 
    140                         printk(KERN_ERR "dt2_pci_preinit failed to " 
    141                                         "irq_set_irq_type pin %d\n", pin); 
     133                        printk(KERN_ERR "%s(%d): failed to " 
     134                                        "irq_set_irq_type pin %d\n", __FUNCTION__, __LINE__, pin); 
    142135                        gpio_free(pin); 
    143136                } 
    144137        } else { 
    145                 printk(KERN_ERR "dt2_pci_preinit failed to gpio_request %d\n", pin); 
     138                printk(KERN_ERR "%s(%d): failed to gpio_request %d\n", __FUNCTION__, __LINE__, pin); 
    146139        } 
    147140} 
    148141 
     
    154147         * Check for devices with hard-wired IRQs. 
    155148         */ 
    156149        irq = orion5x_pci_map_irq(dev, slot, pin); 
    157         if (irq != -1){ 
    158                 printk(KERN_INFO "orion5x_pci_map_irq: %d\n", irq); 
     150        if (irq != -1) 
    159151                return irq; 
    160         } 
    161152 
    162153        /* 
    163          * PCI IRQs are connected via GPIOs 
     154         * PCI IRQs are connected via GPIOs. 
    164155         */ 
    165156        switch (slot - DT2_PCI_SLOT0_OFFS) { 
    166         case 0: 
    167                 if (pin == 1){ 
    168                         irq = gpio_to_irq(DT2_PCI_SLOT0_IRQ_A_PIN); 
    169                         printk(KERN_INFO "dt2_pci_map_irq DT2_PCI_SLOT0_IRQ_A_PIN: %d\n", irq); 
    170                 } 
    171                 else { 
    172                         irq = gpio_to_irq(DT2_PCI_SLOT0_IRQ_B_PIN); 
    173                         printk(KERN_INFO "dt2_pci_map_irq DT2_PCI_SLOT0_IRQ_B_PIN: %d\n", irq); 
    174                 } 
    175         default: 
    176                 irq = -1; 
    177                         printk(KERN_INFO "dt2_pci_map_irq IRQ: %d\n", irq); 
     157                case 0: 
     158                        return gpio_to_irq(DT2_PCI_SLOT0_IRQ_A_PIN); 
     159                case 1: 
     160                        return gpio_to_irq(DT2_PCI_SLOT0_IRQ_B_PIN); 
     161                default: 
     162                        return -1; 
    178163        } 
    179  
    180         return irq; 
    181164} 
    182165 
    183166static struct hw_pci dt2_pci __initdata = { 
     
    223206        .chip           = &dt2_switch_chip_data, 
    224207}; 
    225208 
     209static int dt2_netdev_event(struct notifier_block *this, 
     210                                unsigned long event, void *ptr) 
     211{ 
     212        struct net_device *dev = ptr; 
     213        struct sockaddr mac; 
     214 
     215        if (event == NETDEV_REGISTER && strcmp(dev->name, dt2_switch_chip_data.port_names[0]) == 0) { 
     216                memcpy(mac.sa_data, dt2_eeprom.gw.mac_addr[1], ETH_ALEN); 
     217                if (is_valid_ether_addr(mac.sa_data)) { 
     218                        mac.sa_family = dev->type; 
     219                        dev_set_mac_address(dev, &mac); 
     220                        msleep(2); 
     221                        printk(KERN_INFO 
     222                                "dt2: MAC address now set to %pM for port wan\n", mac.sa_data); 
     223                } 
     224                else { 
     225                        printk(KERN_ERR "dt2: No valid MAC address for port wan\n"); 
     226                } 
     227        } 
     228 
     229        return NOTIFY_DONE; 
     230} 
     231 
     232static struct notifier_block dt2_netdev_notifier = { 
     233        .notifier_call = dt2_netdev_event, 
     234}; 
     235 
    226236/***************************************************************************** 
    227237 * RTC ISL1208 on I2C bus 
    228238 ****************************************************************************/ 
     
    264274        0, 
    265275}; 
    266276 
    267 /***************************************************************************** 
    268  * LEDS 
    269  ****************************************************************************/ 
    270 static struct platform_device dt2_leds = { 
    271         .name           = "dt2-led", 
    272         .id             = -1, 
    273 }; 
    274  
    275 /**************************************************************************** 
    276  * GPIO key 
    277  ****************************************************************************/ 
    278 static irqreturn_t dt2_reset_handler(int irq, void *dev_id) 
    279 { 
    280         /* This is the paper-clip reset which does an emergency reboot. */ 
    281         printk(KERN_INFO "Restarting system.\n"); 
    282         machine_restart(NULL); 
    283  
    284         /* This should never be reached. */ 
    285         return IRQ_HANDLED; 
    286 } 
    287  
    288 static irqreturn_t dt2_power_handler(int irq, void *dev_id) 
    289 { 
    290         printk(KERN_INFO "Shutting down system.\n"); 
    291         machine_power_off(); 
    292         return IRQ_HANDLED; 
    293 } 
    294  
    295277static void __init dt2_init(void) 
    296278{ 
    297279        /* 
     
    304286        /* 
    305287         * Configure peripherals. 
    306288         */ 
    307  
    308289        orion5x_uart0_init(); 
    309290        orion5x_ehci0_init(); 
    310291        orion5x_ehci1_init(); 
     
    312293        orion5x_sata_init(&dt2_sata_data); 
    313294        orion5x_xor_init(); 
    314295 
    315         printk(KERN_INFO "U-Boot parameters:\n"); 
    316         printk(KERN_INFO "Sys Clk = %d, Tclk = %d, BoardID = 0x%02x\n", mvSysclk, mvTclk, gBoardId); 
     296        orion5x_setup_dev_boot_win(DT2_NOR_BOOT_BASE, DT2_NOR_BOOT_SIZE); 
     297        orion5x_setup_dev0_win(DT2_LEDS_BASE, DT2_LEDS_SIZE); 
    317298 
    318         printk(KERN_INFO "Serial: %s\n", dt2_eeprom.fc.dt2_serial_number); 
    319         printk(KERN_INFO "Revision: %016x\n", dt2_eeprom.fc.dt2_revision); 
    320         printk(KERN_INFO "DT2: Using MAC address %pM for port 0\n", 
    321                dt2_eeprom.gw.mac_addr[0]); 
    322         printk(KERN_INFO "DT2: Using MAC address %pM for port 1\n", 
    323                dt2_eeprom.gw.mac_addr[1]); 
     299        printk(KERN_INFO "dt2: Serial: %s\n", dt2_eeprom.fc.dt2_serial_number); 
     300        printk(KERN_INFO "dt2: Revision: %016x\n", dt2_eeprom.fc.dt2_revision); 
    324301 
     302        register_netdevice_notifier(&dt2_netdev_notifier); 
     303 
    325304        orion5x_eth_init(&dt2_eth_data); 
    326305        memcpy(dt2_eth_data.mac_addr, dt2_eeprom.gw.mac_addr[0], 6); 
     306        printk(KERN_INFO "dt2: MAC address now set to %pM for port lan\n",  
     307                                                        dt2_eeprom.gw.mac_addr[0]); 
     308 
    327309        orion5x_eth_switch_init(&dt2_switch_plat_data, NO_IRQ); 
    328310 
    329311        i2c_register_board_info(0, &dt2_i2c_rtc, 1); 
    330312 
    331         orion5x_setup_dev_boot_win(DT2_NOR_BOOT_BASE, DT2_NOR_BOOT_SIZE); 
    332313        platform_device_register(&dt2_nor_flash); 
    333  
    334         orion5x_setup_dev0_win(DT2_LEDS_BASE, DT2_LEDS_SIZE); 
    335314        platform_device_register(&dt2_leds); 
    336  
    337         if (request_irq(gpio_to_irq(DT2_PIN_GPIO_RESET), &dt2_reset_handler, 
    338                         IRQF_DISABLED | IRQF_TRIGGER_LOW, 
    339                         "DT2: Reset button", NULL) < 0) { 
    340  
    341                 printk("DT2: Reset Button IRQ %d not available\n", 
    342                         gpio_to_irq(DT2_PIN_GPIO_RESET)); 
    343         } 
    344  
    345         if (request_irq(gpio_to_irq(DT2_PIN_GPIO_POWER), &dt2_power_handler, 
    346                         IRQF_DISABLED | IRQF_TRIGGER_LOW, 
    347                         "DT2: Power button", NULL) < 0) { 
    348  
    349                 printk(KERN_DEBUG "DT2: Power Button IRQ %d not available\n", 
    350                         gpio_to_irq(DT2_PIN_GPIO_POWER)); 
    351         } 
    352315} 
    353316 
    354317static int __init parse_tag_dt2_uboot(const struct tag *t) 
     
    357320                 
    358321        // Get pointer to our block 
    359322        mv_uboot = (struct tag_mv_uboot*)&t->u; 
    360         mvTclk = mv_uboot->tclk; 
    361         mvSysclk = mv_uboot->sysclk; 
    362         mvUbootVer = mv_uboot->uboot_version; 
    363         mvIsUsbHost = mv_uboot->isUsbHost; 
    364  
    365         // Some clock fixups 
    366         if(mvTclk == 166000000) mvTclk = 166666667; 
    367         else if(mvTclk == 133000000) mvTclk = 133333333; 
    368         else if(mvSysclk == 166000000) mvSysclk = 166666667; 
    369  
    370         gBoardId =  (mvUbootVer & 0xff); 
    371323                         
    372324        //DT2 specific data 
    373325        memcpy(&dt2_eeprom, mv_uboot->dt2_eeprom, sizeof(struct DT2_EEPROM_STRUCT)); 
     
    393345                /* Locate the Freecom cmdline */ 
    394346                if (t->hdr.tag == ATAG_CMDLINE) { 
    395347                        p = t->u.cmdline.cmdline; 
    396                         printk("%s(%d): Found cmdline '%s' at 0x%0lx\n", 
    397                                __FUNCTION__, __LINE__, p, (unsigned long)p); 
     348                        printk(KERN_INFO "Found Freecom cmdline '%s' at 0x%0lx\n", 
     349                               p, (unsigned long)p); 
    398350                } 
    399351                /* 
    400352                 * Many orion-based systems have buggy bootloader implementations. 
     
    410362                } 
    411363        } 
    412364 
    413         printk("%s(%d): End of table at 0x%0lx\n", __FUNCTION__, __LINE__, (unsigned long)t); 
     365        printk(KERN_INFO "End of table at 0x%0lx\n", (unsigned long)t); 
    414366 
    415367        /* Overwrite the end of the table with a new cmdline tag. */  
    416368        t->hdr.tag = ATAG_CMDLINE; 
     
    422374        strlcpy(t->u.cmdline.cmdline + strlen(p), openwrt_init_tag, 
    423375                COMMAND_LINE_SIZE - strlen(p)); 
    424376 
    425         printk("%s(%d): New cmdline '%s' at 0x%0lx\n", 
    426                __FUNCTION__, __LINE__, 
     377        printk(KERN_INFO "Set new OpenWrt cmdline '%s' at 0x%0lx\n",            
    427378               t->u.cmdline.cmdline, (unsigned long)t->u.cmdline.cmdline); 
    428379 
    429380        t = tag_next(t); 
    430381 
    431         printk("%s(%d): New end of table at 0x%0lx\n", __FUNCTION__, __LINE__, (unsigned long)t); 
     382        printk(KERN_INFO "New end of table at 0x%0lx\n", (unsigned long)t); 
    432383 
    433384        t->hdr.tag = ATAG_NONE; 
    434385        t->hdr.size = 0; 
     
    440391        .boot_params    = 0x00000100, 
    441392        .init_machine   = dt2_init, 
    442393        .map_io         = orion5x_map_io, 
     394        .init_early     = orion5x_init_early, 
    443395        .init_irq       = orion5x_init_irq, 
    444396        .timer          = &orion5x_timer, 
    445397        .fixup          = openwrt_fixup, //tag_fixup_mem32, 
    446398MACHINE_END 
     399 
  • files/drivers/input/misc/buttons-dt2.c

     
     1/* 
     2 * dt2-buttons.c 
     3 * 
     4 * Freecom DataTank Gateway buttons driver 
     5 * 
     6 * Copyright (C) 2009 Zintis Petersons <Zintis.Petersons@abcsolutions.lv> 
     7 * 
     8 * This file is licensed under the terms of the GNU General Public 
     9 * License version 2.  This program is licensed "as is" without any 
     10 * warranty of any kind, whether express or implied. 
     11 */ 
     12 
     13#include <linux/module.h> 
     14#include <linux/interrupt.h> 
     15#include <linux/kobject.h> 
     16#include <asm/uaccess.h> 
     17#include <asm/gpio.h> 
     18 
     19#include <linux/workqueue.h> 
     20#include <linux/skbuff.h> 
     21#include <linux/netlink.h> 
     22#include <linux/kobject.h> 
     23extern u64 uevent_next_seqnum(void); 
     24 
     25#include <mach/dt2-common.h> 
     26 
     27struct button_t { 
     28        char *name; 
     29        u32 gpio; 
     30        unsigned long seen; 
     31        u8 pressed; 
     32}; 
     33 
     34static struct button_t buttons[] = { 
     35        {  
     36                .name = "sync", 
     37                .gpio = DT2_PIN_GPIO_SYNC 
     38        }, 
     39        {  
     40                .name = "power", 
     41                .gpio = DT2_PIN_GPIO_POWER 
     42        }, 
     43        {  
     44                .name = "unplug1", 
     45                .gpio = DT2_PIN_GPIO_UNPLUG1 
     46        }, 
     47        {  
     48                .name = "unplug2", 
     49                .gpio = DT2_PIN_GPIO_UNPLUG2 
     50        }, 
     51        {  
     52                .name = "reset", 
     53                .gpio = DT2_PIN_GPIO_RESET 
     54        }, 
     55}; 
     56 
     57struct event_t { 
     58        struct work_struct wq; 
     59        unsigned long seen; 
     60        char *name, *action; 
     61        struct sk_buff *skb; 
     62}; 
     63 
     64static void add_msg(struct event_t *event, char *msg, int argv) 
     65{ 
     66        char *s; 
     67 
     68        if (argv) 
     69                return; 
     70 
     71        s = skb_put(event->skb, strlen(msg) + 1); 
     72        strcpy(s, msg); 
     73} 
     74 
     75static void hotplug_button(struct work_struct *work) 
     76{ 
     77        struct event_t *event = container_of(work, struct event_t, wq); 
     78        char *s; 
     79        static char buf[128]; 
     80 
     81        event->skb = alloc_skb(2048, GFP_KERNEL); 
     82 
     83        s = skb_put(event->skb, strlen(event->action) + 2); 
     84        sprintf(s, "%s@", event->action); 
     85 
     86        add_msg(event, "HOME=/", 0); 
     87        add_msg(event, "PATH=/sbin:/bin:/usr/sbin:/usr/bin", 0); 
     88        add_msg(event, "SUBSYSTEM=button", 0); 
     89        snprintf(buf, 128, "ACTION=%s", event->action); 
     90        add_msg(event, buf, 0); 
     91        snprintf(buf, 128, "BUTTON=%s", event->name); 
     92        add_msg(event, buf, 0); 
     93        snprintf(buf, 128, "SEEN=%ld", event->seen); 
     94        add_msg(event, buf, 0); 
     95        snprintf(buf, 128, "SEQNUM=%llu", uevent_next_seqnum()); 
     96        add_msg(event, buf, 0); 
     97 
     98        NETLINK_CB(event->skb).dst_group = 1;    
     99        broadcast_uevent(event->skb, 0, 1, GFP_KERNEL); 
     100        kfree(event); 
     101} 
     102 
     103static irqreturn_t button_handler(int irq, void *dev_id) 
     104{ 
     105        struct event_t *event; 
     106        int i; 
     107        u32 changed; 
     108 
     109        for (i = 0; i < ARRAY_SIZE(buttons); i++) { 
     110                if (buttons[i].gpio == irq - IRQ_ORION5X_GPIO_START) { 
     111 
     112                        changed = gpio_get_value(buttons[i].gpio); 
     113                        buttons[i].pressed = !buttons[i].pressed; //changed; 
     114 
     115                        if ((event = (struct event_t *)kzalloc (sizeof(struct event_t), GFP_ATOMIC))) { 
     116                                event->name = buttons[i].name; 
     117                                event->action = buttons[i].pressed ? "pressed" : "released"; 
     118 
     119                                if (buttons[i].pressed) { 
     120                                // button pressed 
     121                                        //fix start time 
     122                                        event->seen = 0; 
     123                                        buttons[i].seen = jiffies; 
     124                                } 
     125                                else  
     126                                { 
     127                                //button released 
     128                                        //calculate time seen 
     129                                        event->seen = (jiffies - buttons[i].seen)/HZ; 
     130                                } 
     131 
     132                                INIT_WORK(&event->wq, (void *)(void *)hotplug_button); 
     133                                schedule_work(&event->wq); 
     134                        } 
     135                } 
     136        } 
     137 
     138        return IRQ_HANDLED; 
     139} 
     140 
     141/////////////////////////////////////////////////////////////////////////////////////////////////////// 
     142 
     143static int __init dt2_buttons_init(void) 
     144{ 
     145        int i, irq; 
     146 
     147        for (i = 0; i < ARRAY_SIZE(buttons); i++) { 
     148                irq = gpio_to_irq(buttons[i].gpio); 
     149                if (request_irq(irq, &button_handler, IRQF_DISABLED | IRQF_TRIGGER_RISING | 
     150                                        IRQF_TRIGGER_FALLING, buttons[i].name, NULL) < 0) 
     151                        printk(KERN_ERR "%s(%d): %s button IRQ %d not available\n", __FUNCTION__, __LINE__, buttons[i].name, irq); 
     152                else 
     153                        printk(KERN_INFO "%s button registered on IRQ %d\n", buttons[i].name, irq); 
     154        } 
     155 
     156        return 0; 
     157} 
     158 
     159static void __exit dt2_buttons_exit(void) 
     160{ 
     161        int i, irq; 
     162 
     163        for (i = 0; i < ARRAY_SIZE(buttons); i++) { 
     164                irq = gpio_to_irq(buttons[i].gpio); 
     165                free_irq(gpio_to_irq(irq), NULL); 
     166                printk(KERN_INFO "%s button unregistered from IRQ %d\n", buttons[i].name, irq); 
     167        } 
     168} 
     169 
     170module_init(dt2_buttons_init); 
     171module_exit(dt2_buttons_exit); 
     172 
     173MODULE_AUTHOR("Zintis Petersons <Zintis.Petersons@abcsolutions.lv>"); 
     174MODULE_DESCRIPTION("Freecom DataTank Gateway buttons driver"); 
     175MODULE_LICENSE("GPL"); 
  • files/drivers/leds/leds-dt2.c

    Property changes on: files/drivers/input/misc/buttons-dt2.c
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1/* 
     2 * LED Driver for the Freecom DT2 
     3 * 
     4 * Copyright (c) 2009 Zintis Petersons <Zintis.Petersons@e-mail.lv> 
     5 * 
     6 * Author: Zintis Petersons <Zintis.Petersons@e-mail.lv> 
     7 * 
     8 * Based on leds-fsg.c 
     9 * Copyright 2008 Rod Whitby <rod@whitby.id.au> 
     10 * Author: Rod Whitby <rod@whitby.id.au> 
     11 * 
     12 * This program is free software; you can redistribute it and/or modify 
     13 * it under the terms of the GNU General Public License version 2 as 
     14 * published by the Free Software Foundation. 
     15 * 
     16 */ 
     17 
     18#include <linux/kernel.h> 
     19#include <linux/init.h> 
     20#include <linux/platform_device.h> 
     21#include <linux/leds.h> 
     22#include <mach/hardware.h> 
     23#include <asm/io.h> 
     24 
     25#include <mach/dt2-common.h> 
     26 
     27#define DT2_LEDS_STARTUP        0xFFFF 
     28 
     29static short __iomem *latch_address; 
     30static unsigned short latch_value; 
     31 
     32static void dt2_led_sync_set(struct led_classdev *led_cdev, 
     33                             enum led_brightness value) 
     34{ 
     35        if (value) { 
     36                latch_value &= ~(1 << DT2_LED_POS_SYNC); 
     37                *latch_address = latch_value; 
     38        } else { 
     39                latch_value |=  (1 << DT2_LED_POS_SYNC); 
     40                *latch_address = latch_value; 
     41        } 
     42} 
     43 
     44static void dt2_led_power_set(struct led_classdev *led_cdev, 
     45                             enum led_brightness value) 
     46{ 
     47        if (value) { 
     48                latch_value &= ~(1 << DT2_LED_POS_POWER); 
     49                *latch_address = latch_value; 
     50        } else { 
     51                latch_value |=  (1 << DT2_LED_POS_POWER); 
     52                *latch_address = latch_value; 
     53        } 
     54} 
     55 
     56static void dt2_led_wan_set(struct led_classdev *led_cdev, 
     57                            enum led_brightness value) 
     58{ 
     59        if (value) { 
     60                latch_value &= ~(1 << DT2_LED_POS_WAN); 
     61                *latch_address = latch_value; 
     62        } else { 
     63                latch_value |=  (1 << DT2_LED_POS_WAN); 
     64                *latch_address = latch_value; 
     65        } 
     66} 
     67 
     68static void dt2_led_wlan_set(struct led_classdev *led_cdev, 
     69                             enum led_brightness value) 
     70{ 
     71        if (value) { 
     72                latch_value &= ~(1 << DT2_LED_POS_WLAN); 
     73                *latch_address = latch_value; 
     74        } else { 
     75                latch_value |=  (1 << DT2_LED_POS_WLAN); 
     76                *latch_address = latch_value; 
     77        } 
     78} 
     79 
     80static void dt2_led_usb1_set(struct led_classdev *led_cdev, 
     81                            enum led_brightness value) 
     82{ 
     83        if (value) { 
     84                latch_value &= ~(1 << DT2_LED_POS_USB1); 
     85                *latch_address = latch_value; 
     86        } else { 
     87                latch_value |=  (1 << DT2_LED_POS_USB1); 
     88                *latch_address = latch_value; 
     89        } 
     90} 
     91 
     92static void dt2_led_usb2_set(struct led_classdev *led_cdev, 
     93                            enum led_brightness value) 
     94{ 
     95        if (value) { 
     96                latch_value &= ~(1 << DT2_LED_POS_USB2); 
     97                *latch_address = latch_value; 
     98        } else { 
     99                latch_value |=  (1 << DT2_LED_POS_USB2); 
     100                *latch_address = latch_value; 
     101        } 
     102} 
     103 
     104static void dt2_led_satasw_set(struct led_classdev *led_cdev, 
     105                             enum led_brightness value) 
     106{ 
     107        if (value) { 
     108                latch_value &= ~(1 << DT2_LED_POS_SATASW); 
     109                *latch_address = latch_value; 
     110        } else { 
     111                latch_value |=  (1 << DT2_LED_POS_SATASW); 
     112                *latch_address = latch_value; 
     113        } 
     114} 
     115 
     116static void dt2_led_satahw_set(struct led_classdev *led_cdev, 
     117                             enum led_brightness value) 
     118{ 
     119        if (value) { 
     120                latch_value &= ~(1 << DT2_LED_POS_SATAHW); 
     121                *latch_address = latch_value; 
     122        } else { 
     123                latch_value |=  (1 << DT2_LED_POS_SATAHW); 
     124                *latch_address = latch_value; 
     125        } 
     126} 
     127 
     128static struct led_classdev dt2_leds[] = { 
     129        { 
     130                .name                   = "dt2:blue:sync", 
     131                .brightness_set         = dt2_led_sync_set, 
     132        }, 
     133        { 
     134                .name                   = "dt2:blue:power", 
     135                .brightness_set         = dt2_led_power_set, 
     136        }, 
     137        { 
     138                .name                   = "dt2:blue:wan", 
     139                .brightness_set         = dt2_led_wan_set, 
     140        }, 
     141        { 
     142                .name                   = "dt2:blue:wlan", 
     143                .brightness_set         = dt2_led_wlan_set, 
     144        }, 
     145        { 
     146                .name                   = "dt2:blue:usb1", 
     147                .brightness_set         = dt2_led_usb1_set, 
     148        }, 
     149        { 
     150                .name                   = "dt2:blue:usb2", 
     151                .brightness_set         = dt2_led_usb2_set, 
     152        }, 
     153        { 
     154                .name                   = "dt2:blue:satasw", 
     155                .brightness_set         = dt2_led_satasw_set, 
     156        }, 
     157        { 
     158                .name                   = "dt2:blue:satahw", 
     159                .brightness_set         = dt2_led_satahw_set, 
     160        }, 
     161}; 
     162 
     163static int dt2_led_probe(struct platform_device *pdev) 
     164{ 
     165        int i, x; 
     166        int ret; 
     167 
     168        /* Map the LED chip select address space */ 
     169        latch_address = (unsigned short *) ioremap(DT2_LEDS_BASE, DT2_LEDS_SIZE); 
     170        if (!latch_address) { 
     171                ret = -ENOMEM; 
     172                goto failremap; 
     173        } 
     174 
     175        latch_value = DT2_LEDS_STARTUP; 
     176        *latch_address = latch_value; 
     177         
     178        for (i = 0; i < ARRAY_SIZE(dt2_leds); i++) { 
     179                ret = led_classdev_register(&pdev->dev, &dt2_leds[i]); 
     180                if (ret < 0){ 
     181                        goto failregister; 
     182                } 
     183        } 
     184 
     185        return ret; 
     186 
     187 failregister: 
     188        for (x = 0; x < i-1; x++) 
     189                led_classdev_unregister(&dt2_leds[x]); 
     190 
     191        iounmap(latch_address); 
     192 
     193 failremap: 
     194        return ret; 
     195} 
     196 
     197static int dt2_led_remove(struct platform_device *pdev) 
     198{ 
     199        int i; 
     200         
     201        for (i = 0; i < ARRAY_SIZE(dt2_leds); i++) 
     202                led_classdev_unregister(&dt2_leds[i]); 
     203 
     204        iounmap(latch_address); 
     205 
     206        return 0; 
     207} 
     208 
     209static struct platform_driver dt2_led_driver = { 
     210        .probe          = dt2_led_probe, 
     211        .remove         = dt2_led_remove, 
     212        .driver         = { 
     213                .name           = "dt2-led", 
     214        }, 
     215}; 
     216 
     217static int __init dt2_led_init(void) 
     218{ 
     219        return platform_driver_register(&dt2_led_driver); 
     220} 
     221 
     222static void __exit dt2_led_exit(void) 
     223{ 
     224        platform_driver_unregister(&dt2_led_driver); 
     225} 
     226 
     227module_init(dt2_led_init); 
     228module_exit(dt2_led_exit); 
     229 
     230MODULE_AUTHOR("Zintis Petersons <Zintis.Petersons@abcsolutions.lv>"); 
     231MODULE_DESCRIPTION("Freecom DataTank Gateway LED driver"); 
     232MODULE_LICENSE("GPL"); 
  • files/drivers/hwmon/hwmon-dt2.c

    Property changes on: files/drivers/leds/leds-dt2.c
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1/* 
     2 * Driver for the DT2 Fan-Controller 
     3 * Copyright (C) 2009  Freecom Technologies  <www.openfsg.org> 
     4 * Based on the lm63 driver. 
     5 * 
     6 * 
     7 * This program is free software; you can redistribute it and/or modify 
     8 * it under the terms of the GNU General Public License as published by 
     9 * the Free Software Foundation; either version 2 of the License, or 
     10 * (at your option) any later version. 
     11 * 
     12 * This program is distributed in the hope that it will be useful, 
     13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
     14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     15 * GNU General Public License for more details. 
     16 * 
     17 * You should have received a copy of the GNU General Public License 
     18 * along with this program; if not, write to the Free Software 
     19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
     20 */ 
     21 
     22#include <linux/module.h> 
     23#include <linux/init.h> 
     24#include <linux/slab.h> 
     25#include <linux/jiffies.h> 
     26#include <linux/i2c.h> 
     27#include <linux/hwmon-sysfs.h> 
     28#include <linux/hwmon.h> 
     29#include <linux/err.h> 
     30#include <linux/mutex.h> 
     31#include <linux/sysfs.h> 
     32 
     33/* 
     34 * Addresses to scan 
     35 * Address is fully defined internally and cannot be changed. 
     36 */ 
     37 
     38static const unsigned short normal_i2c[] = { 0x30, I2C_CLIENT_END }; 
     39 
     40/* 
     41 * The LM63 registers 
     42 */ 
     43#define LM63_REG_FORCE_RESET            0x00 
     44#define LM63_REG_PWM_VALUE              0x01 
     45#define LM63_REG_COUNT_OVERFLOW         0x02 
     46#define LM63_REG_ROTATION_DIVISOR       0x03 
     47#define LM63_REG_TEMPERATUR             0x04 
     48#define LM63_REG_STATUS_FLAGS           0x05 
     49 
     50#define LM63_REG_TACHO_RPM_MSB          0x06 
     51#define LM63_REG_TACHO_RPM_LSB          0x07 
     52 
     53#define LM63_REG_TACHO_RAW_MSB          0x08 
     54#define LM63_REG_TACHO_RAW_LSB          0x09 
     55 
     56#define LM63_REG_TACHO_PRE_MSB          0x0A 
     57#define LM63_REG_TACHO_PRE_LSB          0x0B 
     58 
     59 
     60#define LM63_REG_MAGIC_MSB              0x20 
     61#define LM63_REG_MAGIC_LSB              0x21 
     62 
     63#define LM63_REG_SIGNATURE              0x22 
     64#define LM63_REG_SIGNATURE_LENGTH       0x06 
     65 
     66#define LM63_ROM_DESCRIPTION            0x00 
     67#define LM63_ROM_VERSION                0x10 
     68 
     69/* 
     70 * The LM63 defines 
     71 */ 
     72#define PSOC_MAGIC_VALUE                0xFEEC 
     73#define PSOC_MAGIC_VALUE_MSB            0xFE 
     74#define PSOC_MAGIC_VALUE_LSB            0xEC 
     75 
     76#define PSOC_STATUS_GIE                 0x80 
     77#define PSOC_STATUS_PWM_LOCKED          0x40 
     78#define PSOC_STATUS_WDRS                0x20 
     79#define PSOC_STATUS_PORS                0x10 
     80#define PSOC_STATUS_SLEEP               0x08 
     81#define PSOC_STATUS_IRESS               0x04 
     82#define PSOC_STATUS_IRAMDIS             0x02 
     83#define PSOC_STATUS_STOP                0x01 
     84 
     85/* 
     86 * Conversions and various macros 
     87 */ 
     88 
     89#define FAN_FROM_REG(reg)       ((reg)) 
     90#define FAN_TO_REG(val)         ((val)) 
     91#define TEMP_FROM_REG(reg)      ((reg)) 
     92#define TEMP_TO_REG(val)        ((val)) 
     93 
     94 
     95#define DRVNAME                 "DT2-Fan" 
     96 
     97/* 
     98 * Functions declaration 
     99 */ 
     100 
     101static int lm63_probe(struct i2c_client *client, 
     102                      const struct i2c_device_id *id); 
     103static int lm63_remove(struct i2c_client *client); 
     104 
     105static struct lm63_data *lm63_update_device(struct device *dev); 
     106 
     107static int lm63_detect(struct i2c_client *client, 
     108                       struct i2c_board_info *info); 
     109static void lm63_init_client(struct i2c_client *client); 
     110 
     111/* 
     112 * Driver data (common to all clients) 
     113 */ 
     114 
     115static const struct i2c_device_id lm63_id[] = { 
     116        { DRVNAME, 0 }, 
     117        { } 
     118}; 
     119MODULE_DEVICE_TABLE(i2c, lm63_id); 
     120 
     121static struct i2c_driver lm63_driver = { 
     122        .class          = I2C_CLASS_HWMON, 
     123        .driver = { 
     124                .name   = DRVNAME, 
     125        }, 
     126        .probe          = lm63_probe, 
     127        .remove         = lm63_remove, 
     128        .id_table       = lm63_id, 
     129        .detect         = lm63_detect, 
     130        .address_list   = normal_i2c, 
     131}; 
     132 
     133/* 
     134 * Client data (each client gets its own) 
     135 */ 
     136 
     137struct lm63_data { 
     138        struct device *hwmon_dev; 
     139        struct mutex update_lock; 
     140        char valid; /* zero until following fields are valid */ 
     141        unsigned long last_updated; /* in jiffies */ 
     142 
     143        /* registers values */ 
     144        u8 forceReset; 
     145        u8 fanPulseWidth; 
     146        u8 countOverflow; 
     147        u8 rotationDivisor; 
     148        u8 temperatur; 
     149        u8 statusFlags; 
     150        u16 RPM; 
     151        u16 rawPulsesPerRound; 
     152        u16 prePulsesPerRound; 
     153 
     154        u16 id_magic; 
     155        u8 signature[LM63_REG_SIGNATURE_LENGTH]; 
     156        u8 descVersion[255]; 
     157}; 
     158 
     159/* 
     160 * Sysfs callback functions and files 
     161 */ 
     162static ssize_t show_reset(struct device *dev, struct device_attribute *dummy, 
     163                           char *buf) 
     164{ 
     165        struct lm63_data *data = lm63_update_device(dev); 
     166        return sprintf(buf, "%d\n", (data->forceReset)); 
     167} 
     168 
     169static ssize_t set_reset(struct device *dev, struct device_attribute *dummy, 
     170                       const char *buf, size_t count) 
     171{ 
     172        struct i2c_client *client = to_i2c_client(dev); 
     173        struct lm63_data *data = i2c_get_clientdata(client); 
     174        long val = simple_strtol(buf, NULL, 10); 
     175 
     176        mutex_lock(&data->update_lock); 
     177        data->forceReset = (val); 
     178        i2c_smbus_write_byte_data(client, LM63_REG_FORCE_RESET, data->forceReset); 
     179        mutex_unlock(&data->update_lock); 
     180        return count; 
     181} 
     182 
     183static ssize_t show_pwm(struct device *dev, struct device_attribute *dummy, 
     184                           char *buf) 
     185{ 
     186        struct lm63_data *data = lm63_update_device(dev); 
     187        return sprintf(buf, "%d\n", data->fanPulseWidth); 
     188} 
     189 
     190static ssize_t set_pwm(struct device *dev, struct device_attribute *dummy, 
     191                       const char *buf, size_t count) 
     192{ 
     193        struct i2c_client *client = to_i2c_client(dev); 
     194        struct lm63_data *data = i2c_get_clientdata(client); 
     195        unsigned long val; 
     196         
     197        if ((data->statusFlags) & PSOC_STATUS_PWM_LOCKED) 
     198                return -EPERM;                          /* register is read-only */ 
     199 
     200        val = simple_strtoul(buf, NULL, 10); 
     201        mutex_lock(&data->update_lock); 
     202        data->fanPulseWidth = val <= 0 ? 0 : 
     203                              val >= 255 ? 255 : (val); 
     204        i2c_smbus_write_byte_data(client, LM63_REG_PWM_VALUE, data->fanPulseWidth); 
     205        mutex_unlock(&data->update_lock); 
     206        return count; 
     207} 
     208 
     209static ssize_t show_fan_overflow(struct device *dev, struct device_attribute *dummy, 
     210                           char *buf) 
     211{ 
     212        struct lm63_data *data = lm63_update_device(dev); 
     213        return sprintf(buf, "%d\n", data->countOverflow ? 1 : 0); 
     214} 
     215 
     216static ssize_t show_fan_divisor(struct device *dev, struct device_attribute *dummy, 
     217                           char *buf) 
     218{ 
     219        struct lm63_data *data = lm63_update_device(dev); 
     220        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->rotationDivisor)); 
     221} 
     222 
     223static ssize_t set_fan_divisor(struct device *dev, struct device_attribute *dummy, 
     224                       const char *buf, size_t count) 
     225{ 
     226        struct i2c_client *client = to_i2c_client(dev); 
     227        struct lm63_data *data = i2c_get_clientdata(client); 
     228        long val = simple_strtol(buf, NULL, 10); 
     229 
     230        mutex_lock(&data->update_lock); 
     231        data->rotationDivisor = TEMP_TO_REG(val); 
     232        i2c_smbus_write_byte_data(client, LM63_REG_ROTATION_DIVISOR, data->rotationDivisor); 
     233        mutex_unlock(&data->update_lock); 
     234        return count; 
     235} 
     236 
     237static ssize_t show_temp(struct device *dev, struct device_attribute *dummy, 
     238                           char *buf) 
     239{ 
     240        struct lm63_data *data = lm63_update_device(dev); 
     241        int temp; 
     242         
     243        temp = (int)((data->temperatur / 3) * (data->temperatur < 150 ? 1000 : 1150)); 
     244        return sprintf(buf, "%d.%02d\n", (temp / 1000), (temp % 1000)); 
     245} 
     246 
     247static ssize_t set_temp(struct device *dev, struct device_attribute *dummy, 
     248                       const char *buf, size_t count) 
     249{ 
     250        struct i2c_client *client = to_i2c_client(dev); 
     251        struct lm63_data *data = i2c_get_clientdata(client); 
     252        long val = simple_strtol(buf, NULL, 10); 
     253 
     254        mutex_lock(&data->update_lock); 
     255        data->temperatur = TEMP_TO_REG(val); 
     256        i2c_smbus_write_byte_data(client, LM63_REG_TEMPERATUR, data->temperatur); 
     257        mutex_unlock(&data->update_lock); 
     258        return count; 
     259} 
     260 
     261static ssize_t show_status_flags(struct device *dev, struct device_attribute *dummy, 
     262                           char *buf) 
     263{ 
     264        struct lm63_data *data = lm63_update_device(dev); 
     265 
     266        return sprintf(buf, "%d\n\nGIEnble: %d\nPWMLock: %d\nWDReset: %d\nPOReset: %d\nSLEEP  : %d\nIRESS  : %d\nIRAMDIS: %d\nSTOP   : %d\n", 
     267                        (data->statusFlags), (data->statusFlags & PSOC_STATUS_GIE ? 1 : 0), (data->statusFlags & PSOC_STATUS_PWM_LOCKED ? 1 : 0), 
     268                                             (data->statusFlags & PSOC_STATUS_WDRS ? 1 : 0), (data->statusFlags & PSOC_STATUS_PORS ? 1 : 0), 
     269                                             (data->statusFlags & PSOC_STATUS_SLEEP ? 1 : 0), (data->statusFlags & PSOC_STATUS_IRESS ? 1 : 0), 
     270                                             (data->statusFlags & PSOC_STATUS_IRAMDIS ? 1 : 0), (data->statusFlags & PSOC_STATUS_STOP ? 1 : 0)); 
     271} 
     272 
     273static ssize_t set_status_flags(struct device *dev, struct device_attribute *dummy, 
     274                       const char *buf, size_t count) 
     275{ 
     276        struct i2c_client *client = to_i2c_client(dev); 
     277        struct lm63_data *data = i2c_get_clientdata(client); 
     278        long val = simple_strtol(buf, NULL, 10); 
     279 
     280        mutex_lock(&data->update_lock); 
     281        data->statusFlags = (val); 
     282        i2c_smbus_write_byte_data(client, LM63_REG_STATUS_FLAGS, data->statusFlags); 
     283        mutex_unlock(&data->update_lock); 
     284        return count; 
     285} 
     286 
     287static ssize_t show_rpm(struct device *dev, struct device_attribute *dummy, 
     288                           char *buf) 
     289{ 
     290        struct lm63_data *data = lm63_update_device(dev); 
     291        return sprintf(buf, "%d\n", FAN_FROM_REG(data->RPM)); 
     292} 
     293 
     294static ssize_t set_rpm(struct device *dev, struct device_attribute *dummy, 
     295                       const char *buf, size_t count) 
     296{ 
     297        struct i2c_client *client = to_i2c_client(dev); 
     298        struct lm63_data *data = i2c_get_clientdata(client); 
     299        unsigned long val = simple_strtoul(buf, NULL, 10); 
     300 
     301        mutex_lock(&data->update_lock); 
     302        data->RPM = FAN_TO_REG(val); 
     303        i2c_smbus_write_byte_data(client, LM63_REG_TACHO_RPM_LSB, 
     304                                  data->RPM & 0xFF); 
     305        i2c_smbus_write_byte_data(client, LM63_REG_TACHO_RPM_MSB, 
     306                                  data->RPM >> 8); 
     307        mutex_unlock(&data->update_lock); 
     308        return count; 
     309} 
     310 
     311static ssize_t show_raw(struct device *dev, struct device_attribute *dummy, 
     312                           char *buf) 
     313{ 
     314        struct lm63_data *data = lm63_update_device(dev); 
     315        return sprintf(buf, "%d\n", FAN_FROM_REG(data->rawPulsesPerRound)); 
     316} 
     317 
     318static ssize_t set_raw(struct device *dev, struct device_attribute *dummy, 
     319                       const char *buf, size_t count) 
     320{ 
     321        struct i2c_client *client = to_i2c_client(dev); 
     322        struct lm63_data *data = i2c_get_clientdata(client); 
     323        unsigned long val = simple_strtoul(buf, NULL, 10); 
     324 
     325        mutex_lock(&data->update_lock); 
     326        data->rawPulsesPerRound = FAN_TO_REG(val); 
     327        i2c_smbus_write_byte_data(client, LM63_REG_TACHO_RAW_LSB, 
     328                                  data->rawPulsesPerRound & 0xFF); 
     329        i2c_smbus_write_byte_data(client, LM63_REG_TACHO_RAW_MSB, 
     330                                  data->rawPulsesPerRound >> 8); 
     331        mutex_unlock(&data->update_lock); 
     332        return count; 
     333} 
     334 
     335static ssize_t show_pre(struct device *dev, struct device_attribute *dummy, 
     336                           char *buf) 
     337{ 
     338        struct lm63_data *data = lm63_update_device(dev); 
     339        return sprintf(buf, "%d\n", FAN_FROM_REG(data->prePulsesPerRound)); 
     340} 
     341 
     342static ssize_t set_pre(struct device *dev, struct device_attribute *dummy, 
     343                       const char *buf, size_t count) 
     344{ 
     345        struct i2c_client *client = to_i2c_client(dev); 
     346        struct lm63_data *data = i2c_get_clientdata(client); 
     347        unsigned long val = simple_strtoul(buf, NULL, 10); 
     348 
     349        mutex_lock(&data->update_lock); 
     350        data->prePulsesPerRound = FAN_TO_REG(val); 
     351        i2c_smbus_write_byte_data(client, LM63_REG_TACHO_PRE_LSB, 
     352                                  data->prePulsesPerRound & 0xFF); 
     353        i2c_smbus_write_byte_data(client, LM63_REG_TACHO_PRE_MSB, 
     354                                  data->prePulsesPerRound >> 8); 
     355        mutex_unlock(&data->update_lock); 
     356        return count; 
     357} 
     358 
     359static ssize_t show_magic(struct device *dev, struct device_attribute *dummy, 
     360                           char *buf) 
     361{ 
     362        struct lm63_data *data = lm63_update_device(dev); 
     363        return sprintf(buf, "%04X\n", data->id_magic); 
     364} 
     365 
     366static ssize_t show_signature(struct device *dev, struct device_attribute *dummy, 
     367                           char *buf) 
     368{ 
     369        struct lm63_data *data = lm63_update_device(dev); 
     370        return sprintf(buf, "%s\n", data->signature); 
     371} 
     372 
     373static ssize_t show_version(struct device *dev, struct device_attribute *dummy, 
     374                           char *buf) 
     375{ 
     376        struct lm63_data *data = lm63_update_device(dev); 
     377        return sprintf(buf, "%s\n", data->descVersion); 
     378} 
     379 
     380static DEVICE_ATTR(reset, S_IWUSR | S_IRUGO, show_reset, set_reset); 
     381 
     382static DEVICE_ATTR(pwm, S_IWUSR | S_IRUGO, show_pwm, set_pwm); 
     383 
     384static DEVICE_ATTR(fan_overflow, S_IRUGO, show_fan_overflow, NULL); 
     385 
     386static DEVICE_ATTR(fan_divisor, S_IWUSR | S_IRUGO, show_fan_divisor, set_fan_divisor); 
     387 
     388static DEVICE_ATTR(temp_pcb, S_IRUGO, show_temp, NULL); 
     389static DEVICE_ATTR(temp_max, S_IWUSR | S_IRUGO, show_temp, set_temp); 
     390 
     391static DEVICE_ATTR(status_flags, S_IWUSR | S_IRUGO, show_status_flags, set_status_flags); 
     392 
     393static DEVICE_ATTR(fan_rpm, S_IRUGO, show_rpm, NULL); 
     394static DEVICE_ATTR(fan_min, S_IWUSR | S_IRUGO, show_rpm, set_rpm); 
     395 
     396static DEVICE_ATTR(rotation_raw, S_IRUGO, show_raw, NULL); 
     397static DEVICE_ATTR(rotation_min, S_IWUSR | S_IRUGO, show_raw, set_raw); 
     398 
     399static DEVICE_ATTR(rotation_pre, S_IWUSR | S_IRUGO, show_pre, set_pre); 
     400 
     401static DEVICE_ATTR(magic, S_IRUGO, show_magic, NULL); 
     402static DEVICE_ATTR(signature, S_IRUGO, show_signature, NULL); 
     403static DEVICE_ATTR(version, S_IRUGO, show_version, NULL); 
     404 
     405static struct attribute *lm63_attributes[] = { 
     406        &dev_attr_reset.attr, 
     407        &dev_attr_pwm.attr, 
     408 
     409        &dev_attr_fan_overflow.attr, 
     410        &dev_attr_fan_divisor.attr, 
     411 
     412        &dev_attr_temp_pcb.attr, 
     413        &dev_attr_temp_max.attr, 
     414 
     415        &dev_attr_status_flags.attr, 
     416 
     417        &dev_attr_fan_rpm.attr, 
     418        &dev_attr_fan_min.attr, 
     419 
     420        &dev_attr_rotation_raw.attr, 
     421        &dev_attr_rotation_min.attr, 
     422        &dev_attr_rotation_pre.attr, 
     423 
     424        &dev_attr_magic.attr, 
     425        &dev_attr_signature.attr, 
     426        &dev_attr_version.attr, 
     427        NULL 
     428}; 
     429 
     430static const struct attribute_group lm63_group = { 
     431        .attrs = lm63_attributes, 
     432}; 
     433 
     434/* 
     435 * Real code 
     436 */ 
     437 
     438/* Return 0 if detection is successful, -ENODEV otherwise */ 
     439static int lm63_detect(struct i2c_client *new_client, 
     440                       struct i2c_board_info *info) 
     441{ 
     442        struct i2c_adapter *adapter = new_client->adapter; 
     443 
     444        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 
     445                return -ENODEV; 
     446 
     447        u8 magic_hi, magic_lo; 
     448 
     449        magic_hi = i2c_smbus_read_byte_data(new_client, 
     450                 LM63_REG_MAGIC_MSB); 
     451        magic_lo = i2c_smbus_read_byte_data(new_client, 
     452                 LM63_REG_MAGIC_LSB); 
     453 
     454        if (magic_hi != PSOC_MAGIC_VALUE_MSB    /* check for MAGIC value of PSoC */ 
     455         || magic_lo != PSOC_MAGIC_VALUE_LSB) { 
     456                dev_dbg(&adapter->dev, "Unsupported chip " 
     457                        "(man_id=0x%02X, chip_id=0x%02X).\n", 
     458                        magic_hi, magic_lo); 
     459                return -ENODEV; 
     460        } 
     461 
     462        strlcpy(info->type, DRVNAME, I2C_NAME_SIZE); 
     463 
     464        return 0; 
     465} 
     466 
     467static int lm63_probe(struct i2c_client *new_client, 
     468                      const struct i2c_device_id *id) 
     469{ 
     470        struct lm63_data *data; 
     471        int err; 
     472 
     473        data = kzalloc(sizeof(struct lm63_data), GFP_KERNEL); 
     474        if (!data) { 
     475                err = -ENOMEM; 
     476                goto exit; 
     477        } 
     478 
     479        i2c_set_clientdata(new_client, data); 
     480        data->valid = 0; 
     481        mutex_init(&data->update_lock); 
     482 
     483        /* Initialize the LM63 chip */ 
     484        lm63_init_client(new_client); 
     485 
     486        /* Register sysfs hooks */ 
     487        if ((err = sysfs_create_group(&new_client->dev.kobj, 
     488                                      &lm63_group))) 
     489                goto exit_free; 
     490 
     491        data->hwmon_dev = hwmon_device_register(&new_client->dev); 
     492        if (IS_ERR(data->hwmon_dev)) { 
     493                err = PTR_ERR(data->hwmon_dev); 
     494                goto exit_remove_files; 
     495        } 
     496 
     497        return 0; 
     498 
     499exit_remove_files: 
     500        sysfs_remove_group(&new_client->dev.kobj, &lm63_group); 
     501exit_free: 
     502        kfree(data); 
     503exit: 
     504        return err; 
     505} 
     506 
     507/* Idealy we shouldn't have to initialize anything, since the BIOS 
     508   should have taken care of everything */ 
     509static void lm63_init_client(struct i2c_client *client) 
     510{ 
     511        unsigned char dummy, temp, adress; 
     512        struct lm63_data *data = i2c_get_clientdata(client); 
     513 
     514        data->fanPulseWidth = i2c_smbus_read_byte_data(client, LM63_REG_PWM_VALUE); 
     515 
     516        data->id_magic  = (i2c_smbus_read_byte_data(client, LM63_REG_MAGIC_MSB) << 8) 
     517                        | (i2c_smbus_read_byte_data(client, LM63_REG_MAGIC_LSB)); 
     518 
     519        for (dummy = 0; dummy < LM63_REG_SIGNATURE_LENGTH; ) 
     520        { 
     521                temp = i2c_smbus_read_byte_data(client, LM63_REG_SIGNATURE + dummy); 
     522                data->signature[dummy++] = temp; 
     523                if (!temp) break; 
     524        }        
     525 
     526        /* Read EEPROM partition of PSoC */ 
     527        adress = client->addr; 
     528        client->addr = adress | 0x40; 
     529 
     530        for (dummy = 0; dummy < 255; ) 
     531        { 
     532                temp = i2c_smbus_read_byte_data(client, LM63_ROM_DESCRIPTION + dummy); 
     533                data->descVersion[dummy++] = temp; 
     534                if (!temp) break; 
     535        }        
     536        client->addr = adress; 
     537 
     538        printk(KERN_INFO "hwmon-dt2: %s -%s initialized.\n", data->descVersion, data->signature); 
     539} 
     540 
     541static int lm63_remove(struct i2c_client *client) 
     542{ 
     543        struct lm63_data *data = i2c_get_clientdata(client); 
     544 
     545        hwmon_device_unregister(data->hwmon_dev); 
     546        sysfs_remove_group(&client->dev.kobj, &lm63_group); 
     547 
     548        kfree(data); 
     549        return 0; 
     550} 
     551 
     552static struct lm63_data *lm63_update_device(struct device *dev) 
     553{ 
     554        struct i2c_client *client = to_i2c_client(dev); 
     555        struct lm63_data *data = i2c_get_clientdata(client); 
     556 
     557        mutex_lock(&data->update_lock); 
     558 
     559        if (time_after(jiffies, data->last_updated + HZ) || !data->valid) { 
     560                data->fanPulseWidth = i2c_smbus_read_byte_data(client, LM63_REG_PWM_VALUE); 
     561 
     562                data->forceReset = i2c_smbus_read_byte_data(client, LM63_REG_FORCE_RESET); 
     563 
     564                data->countOverflow = i2c_smbus_read_byte_data(client, LM63_REG_COUNT_OVERFLOW); 
     565 
     566                data->rotationDivisor = i2c_smbus_read_byte_data(client, LM63_REG_ROTATION_DIVISOR); 
     567 
     568                data->temperatur = i2c_smbus_read_byte_data(client, LM63_REG_TEMPERATUR); 
     569 
     570                data->statusFlags = i2c_smbus_read_byte_data(client, LM63_REG_STATUS_FLAGS); 
     571 
     572                data->RPM = (i2c_smbus_read_byte_data(client, LM63_REG_TACHO_RPM_MSB) << 8) 
     573                          | (i2c_smbus_read_byte_data(client, LM63_REG_TACHO_RPM_LSB)); 
     574 
     575                data->rawPulsesPerRound = (i2c_smbus_read_byte_data(client, LM63_REG_TACHO_RAW_MSB) << 8) 
     576                                        | (i2c_smbus_read_byte_data(client, LM63_REG_TACHO_RAW_LSB)); 
     577 
     578                data->prePulsesPerRound = (i2c_smbus_read_byte_data(client, LM63_REG_TACHO_PRE_MSB) << 8) 
     579                                        | (i2c_smbus_read_byte_data(client, LM63_REG_TACHO_PRE_LSB)); 
     580 
     581                data->last_updated = jiffies; 
     582                data->valid = 1; 
     583        } 
     584 
     585        mutex_unlock(&data->update_lock); 
     586 
     587        return data; 
     588} 
     589 
     590static int __init sensors_lm63_init(void) 
     591{ 
     592        return i2c_add_driver(&lm63_driver); 
     593} 
     594 
     595static void __exit sensors_lm63_exit(void) 
     596{ 
     597        i2c_del_driver(&lm63_driver); 
     598} 
     599 
     600MODULE_AUTHOR("Freecom Technologies  <www.openfsg.org>"); 
     601MODULE_DESCRIPTION("DT2 Fan-Controller driver"); 
     602MODULE_LICENSE("GPL"); 
     603 
     604module_init(sensors_lm63_init); 
     605module_exit(sensors_lm63_exit); 
  • image/harddisk.mk

    Property changes on: files/drivers/hwmon/hwmon-dt2.c
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
    99        cp $(LINUX_DIR)/arch/arm/boot/uImage $(KDIR)/uImage 
    1010endef 
    1111 
     12define Build/Clean 
     13        $(MAKE) -C decodefw-dt2 clean 
     14        $(MAKE) -C uboot-dt2 clean 
     15endef 
     16 
    1217define Image/BuildKernel 
    1318        # Orion Kernel uImages 
    1419 # DT2: mach id 1514 (0x5EA) 
     
    1722        $(STAGING_DIR_HOST)/bin/mkimage -A arm -O linux -T kernel \ 
    1823        -C none -a 0x00008000 -e 0x00008000 -n 'Linux-$(LINUX_VERSION)' \ 
    1924        -d $(KDIR)/dt2-zImage $(KDIR)/dt2-uImage 
    20         cp $(KDIR)/dt2-uImage $(BIN_DIR)/openwrt-dt2-uImage 
    2125endef 
    2226 
    2327define Image/Build/Freecom 
     
    2529 # backup unwanted files 
    2630        rm -rf ${TMP_DIR}/$2_backup 
    2731        mkdir ${TMP_DIR}/$2_backup 
    28         -mv $(TARGET_DIR)/{var,jffs,rom} ${TMP_DIR}/$2_backup 
     32        -mv $(TARGET_DIR)/{var,jffs,rom,overlay} ${TMP_DIR}/$2_backup 
     33        mkdir ${TMP_DIR}/$2_backup/lib 
     34        -mv $(TARGET_DIR)/lib/firstboot ${TMP_DIR}/$2_backup/lib 
     35        mkdir ${TMP_DIR}/$2_backup/lib/preinit 
     36        -mv $(TARGET_DIR)/lib/preinit/{10_check_for_mtd,20_check_jffs2_ready,40_mount_jffs2,70_pivot_jffs2_root,90_mount_no_jffs2,99_10_mount_no_mtd} \          ${TMP_DIR}/$2_backup/lib/preinit 
     37        mkdir ${TMP_DIR}/$2_backup/sbin 
     38        -mv $(TARGET_DIR)/sbin/{firstboot,mount_root} ${TMP_DIR}/$2_backup/sbin 
     39 
     40        $(MAKE) -C decodefw-dt2 TARGET="$(TARGET_DIR)/usr/bin" clean install 
     41        $(MAKE) -C uboot-dt2 TARGET="$(TARGET_DIR)/usr/bin" clean install 
     42 
    2943 # add extra files 
    3044        $(INSTALL_DIR) $(TARGET_DIR)/boot 
    3145        # TODO: Add special CMDLINE shim for webupgrade image here 
    3246        $(CP) $(KDIR)/dt2-uImage $(TARGET_DIR)/boot/uImage 
    3347        $(INSTALL_DIR) $(TARGET_DIR)/var 
    3448 # create image 
    35         $(TAR) cfj $(BIN_DIR)/openwrt-$(2)-$(1).img --numeric-owner --owner=0 --group=0 -C $(TARGET_DIR)/ . 
    36         $(STAGING_DIR_HOST)/bin/encode_crc $(BIN_DIR)/openwrt-$(2)-$(1).img $(BIN_DIR)/openwrt-$(2)-$(1)-webupgrade.img $(3) 
     49        $(TAR) cfj $(BIN_DIR)/$(IMG_PREFIX)-$2.tar.bz2 --numeric-owner --owner=0 --group=0 -C $(TARGET_DIR)/ . 
     50        $(STAGING_DIR_HOST)/bin/encode_crc $(BIN_DIR)/$(IMG_PREFIX)-$2.tar.bz2 $(BIN_DIR)/$(IMG_PREFIX)-$2-webupgrade.img $(3) 
     51        rm -rf $(BIN_DIR)/$(IMG_PREFIX)-$2.tar.bz2 
    3752 # remove extra files 
    3853        rm -rf $(TARGET_DIR)/{boot,var} 
     54        rm -rf $(TARGET_DIR)/usr/bin/{decodefw-dt2,uboot-dt2} 
     55 
    3956 # recover unwanted files 
    40         -mv ${TMP_DIR}/$2_backup/* $(TARGET_DIR)/ 
     57        -cp -R ${TMP_DIR}/$2_backup/* $(TARGET_DIR)/ 
    4158        rm -rf ${TMP_DIR}/$2_backup 
    4259endef 
    4360 
    4461define Image/Build 
    45 $(call Image/Build/$(1),$(1)) 
    46 $(call Image/Build/Freecom,$(1),dt2,DT,$(1)) 
     62$(call Image/Build/Freecom,$(1),dt2,DT) 
    4763endef 
    4864 
    49 define Image/Build/squashfs 
    50 $(call prepare_generic_squashfs,$(KDIR)/root.squashfs) 
    51         ( \ 
    52                 dd if=$(KDIR)/uImage bs=1024k conv=sync; \ 
    53                 dd if=$(KDIR)/root.$(1) bs=128k conv=sync; \ 
    54         ) > $(BIN_DIR)/$(IMG_PREFIX)-$(1).img 
    55 endef 
  • image/uboot-dt2/src/uboot-dt2.c

     
     1/* 
     2 * Read, write or list Freecom DataTank u-boot configuration 
     3 * 
     4 * Copyright (c) 2009 Zintis Petersons <Zintis.Petersons@abcsolutions.lv> 
     5 * 
     6 * Author: Zintis Petersons <Zintis.Petersons@abcsolutions.lv> 
     7 * 
     8 * This program is free software; you can redistribute it and/or modify 
     9 * it under the terms of the GNU General Public License version 2 as 
     10 * published by the Free Software Foundation. 
     11 * 
     12 */ 
     13 
     14#include <stdio.h> 
     15#include <stdlib.h> 
     16#include <stdint.h> 
     17#include <string.h> 
     18#include <unistd.h> 
     19#include <fcntl.h> 
     20#include <getopt.h> 
     21#include <sys/ioctl.h> 
     22 
     23#include "debug.h" 
     24#include "crc.h" 
     25#include "crunchfc.h" 
     26 
     27#define MODE_NONE 0 
     28#define MODE_WRITE 1 
     29#define MODE_READ 2 
     30#define MODE_LIST 3 
     31 
     32/* 
     33 * Print usage information. 
     34 */ 
     35static void usage(void) 
     36{ 
     37        uint8_t i; 
     38        if (verbosity == 0) { 
     39                return; 
     40        } 
     41 
     42        fputs("Read, write or list Freecom DataTank u-boot configuration\n", stdout); 
     43        fputs("usage: uboot-dt2 [-r|-w|-l]" 
     44              " -d dev -n nickname -x value\n", stdout); 
     45        fputs("'dev' may be a char device, block device or a file\n", stdout); 
     46        fputs("Additional switches: \n", stdout); 
     47        fputs(" -v:\tVerbose mode, use more to increase verbosity\n", stdout); 
     48        fputs(" -s:\tSilent mode, absolutely no messages printed\n", stdout); 
     49} 
     50 
     51/* 
     52 * Open the file or device containing configuration and copy the configuration  
     53 * data to a buffer. We could mmap() here and operate directly on mmaped data  
     54 * (it'd make life easier later), but that would force us to work with MTD in  
     55 * block device emulation mode (see comments at the top of this file).  
     56 * 
     57 * Remember, that the MTD partition is likely to be "forced read-only",  
     58 * if the partition size is not equal to erase block size. 
     59 */ 
     60 
     61struct config_data *get_dev_handle(struct config_data *data,  
     62        uint8_t *dev, const char *mode) 
     63{ 
     64        if ((data->fd = fopen(dev, mode)) < 0) { 
     65                MESSAGE(VERB_LOW, "Failed to open device or file %s!\n", dev); 
     66                return NULL; 
     67        } 
     68 
     69        data->buf = (unsigned char *)malloc(ENV_SIZE); 
     70 
     71        if(fread(data->buf, ENV_SIZE, 1, data->fd) != 1) { 
     72                MESSAGE(VERB_LOW, "Failed to read device or file %s!\n", dev); 
     73                return NULL; 
     74        } 
     75 
     76        return data; 
     77} 
     78 
     79/* 
     80 * Synchronize the data back and close the file or device containing  
     81 * the configuration data.  
     82 */ 
     83void close_dev_handle(struct config_data *data) 
     84{ 
     85        fclose(data->fd); 
     86} 
     87 
     88/* 
     89 * Read mode of operation: get parameter values from the configuration.  
     90 */ 
     91static int read_mode(uint8_t *device, uint8_t *nickname) 
     92{ 
     93        struct config_data data; 
     94        if (get_dev_handle(&data, device, "r") == NULL) { 
     95                MESSAGE(VERB_LOW, "Could not get a config data handle!\n"); 
     96                return 1; 
     97        } 
     98 
     99        if (get_key_value(&data, nickname)) { 
     100                goto exit_fail; 
     101        } 
     102 
     103        close_dev_handle(&data); 
     104        return 0; 
     105 
     106exit_fail: 
     107        close_dev_handle(&data); 
     108        return 1; 
     109} 
     110 
     111/* 
     112 * Write mode of operation: set parameter values in the configuration.  
     113 */ 
     114static int write_mode(uint8_t *device, uint8_t *nickname, uint8_t *value) 
     115{ 
     116        struct config_data data; 
     117        unsigned char *memFlash = (unsigned char *)malloc(ENV_SIZE); 
     118 
     119        if (value == NULL) { 
     120                MESSAGE(VERB_LOW, "You must provide a value in WRITE mode\n"); 
     121                return 1; 
     122        } 
     123 
     124        if (get_dev_handle(&data, device, "r") == NULL) { 
     125                MESSAGE(VERB_LOW, "Could not get a config data handle!\n"); 
     126                return 1; 
     127        } 
     128 
     129        if (set_key_value(&data, nickname, value)) { 
     130                goto exit_fail; 
     131        } 
     132 
     133        close_dev_handle(&data); 
     134 
     135        memcpy(memFlash, data.buf, ENV_SIZE); 
     136 
     137        *((cyg_uint32*)memFlash) = 
     138                cyg_crc32_accumulate(0xffffffffL, memFlash+4, ENV_SIZE-4) ^ 0xffffffffL; 
     139 
     140        FILE *f = fopen(device, "w"); 
     141        if(fwrite(memFlash, ENV_SIZE, 1, f) != 1) { 
     142                MESSAGE(VERB_LOW, "Failed to write device or file!\n"); 
     143                return 1; 
     144        } 
     145        fclose(f); 
     146 
     147        return 0; 
     148 
     149exit_fail:  
     150        close_dev_handle(&data); 
     151        return 1; 
     152} 
     153 
     154/* 
     155 * List mode of operation: list parameter values from the configuration. 
     156 */ 
     157static int list_mode(uint8_t *device) 
     158{ 
     159        struct config_data data; 
     160        if (get_dev_handle(&data, device, "r") == NULL) { 
     161                MESSAGE(VERB_LOW, "Could not get a config data handle!\n"); 
     162                return 1; 
     163        } 
     164 
     165        if (list_keys(&data)) { 
     166                goto exit_fail; 
     167        } 
     168 
     169        close_dev_handle(&data); 
     170        return 0; 
     171 
     172exit_fail: 
     173        close_dev_handle(&data); 
     174        return 1; 
     175} 
     176 
     177/* 
     178 * main(). 
     179 */ 
     180int main(int argc, char **argv) 
     181{ 
     182        int c, ret; 
     183        uint8_t mode = MODE_NONE; 
     184        uint8_t *nickname = NULL; 
     185        uint8_t *value = NULL; 
     186        uint8_t *device = NULL; 
     187 
     188        while ((c = getopt(argc, argv, "hrwlvsd:n:x:")) != -1) { 
     189                switch (c) { 
     190                case 'r': 
     191                        mode = MODE_READ; 
     192                        break; 
     193                case 'w': 
     194                        mode = MODE_WRITE; 
     195                        break; 
     196                case 'l': 
     197                        mode = MODE_LIST; 
     198                        break; 
     199                case 'n': 
     200                        nickname = optarg; 
     201                        break; 
     202                case 'x': 
     203                        value = optarg; 
     204                        break; 
     205                case 'v': 
     206                        verbosity++; 
     207                        break; 
     208                case 's': 
     209                        verbosity = 0; 
     210                        break; 
     211                case 'd': 
     212                        device = optarg; 
     213                        break; 
     214                case 'h': 
     215                        usage(); 
     216                        break; 
     217                case '?': 
     218                default: 
     219                        usage(); 
     220                        exit(1); 
     221                        break; 
     222                } 
     223        } 
     224 
     225        MESSAGE(VERB_LOW, "Low verbosity messages are printed.\n"); 
     226        MESSAGE(VERB_NORMAL, "Normal verbosity messages are printed.\n"); 
     227        MESSAGE(VERB_HIGH, "High verbosity messages are printed.\n"); 
     228 
     229        if ((mode == MODE_NONE) && (device != NULL)) { 
     230                mode = MODE_LIST; 
     231        } 
     232 
     233        if ((nickname == NULL) && (mode != MODE_LIST)) { 
     234                usage(); 
     235                exit(1); 
     236        } 
     237 
     238        if (device == NULL) { 
     239                MESSAGE(VERB_LOW, "You must provide a device name.\n"); 
     240                exit(1); 
     241        } 
     242 
     243        switch (mode) { 
     244                case MODE_READ : 
     245                        ret = read_mode(device, nickname); 
     246                        break; 
     247                case MODE_WRITE : 
     248                        ret = write_mode(device, nickname, value); 
     249                        break; 
     250                case MODE_LIST : 
     251                        ret = list_mode(device); 
     252                        break; 
     253                default : 
     254                        MESSAGE(VERB_LOW, "Unknown mode of operation\n"); 
     255                        usage(); 
     256                        ret = 1; 
     257        } //switch 
     258 
     259        return ret; 
     260} 
  • image/uboot-dt2/src/crunchfc.h

    Property changes on: image/uboot-dt2/src/uboot-dt2.c
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1#ifndef CRUNCHFC_H 
     2#define CRUNCHFC_H 
     3 
     4#include <stdint.h> 
     5 
     6#define ENV_SIZE  0x1000 
     7 
     8struct config_data { 
     9        FILE *fd; 
     10        unsigned char *buf; 
     11}; 
     12 
     13int8_t list_keys(struct config_data *data); 
     14int8_t get_key_value(struct config_data *data, uint8_t *nickname); 
     15int8_t set_key_value(struct config_data *data, uint8_t *nickname, void *value); 
     16 
     17#endif //CRUNCHFC_H 
     18 
  • image/uboot-dt2/src/debug.c

    Property changes on: image/uboot-dt2/src/crunchfc.h
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1/* 
     2 * debug.c 
     3 * 
     4 * $Id: debug.c,v 1.1 2006/02/13 09:58:08 andrzej Exp $ 
     5 * 
     6 * Redboot Flash Configuration parser.  
     7 * Debug utilities.  
     8 * 
     9 * Copyright (C) 2006 Ekiert sp z o.o. 
     10 * Author: Andrzej Ekiert <a.ekiert@ekiert.com> 
     11 * 
     12 * This program is free software; you can redistribute it and/or 
     13 * modify it under the terms of the GNU General Public License 
     14 * as published by the Free Software Foundation; either version 
     15 * 2 of the License, or (at your option) any later version.  
     16 */ 
     17#include <stdio.h> 
     18 
     19#include "debug.h" 
     20 
     21uint8_t verbosity = VERB_LOW; 
     22 
     23void hex_dump(void *buf, uint16_t len) 
     24{ 
     25        uint16_t i; 
     26        for (i = 0 ; i < len; i++) { 
     27                printf("%02x", ((uint8_t*)buf)[i]); 
     28                if (i%2) { 
     29                        printf(" "); 
     30                } 
     31                if (15 == i%16) { 
     32                        printf("\n"); 
     33                } 
     34        } 
     35        printf("\n"); 
     36} 
     37 
  • image/uboot-dt2/src/crc.c

    Property changes on: image/uboot-dt2/src/debug.c
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1/* 
     2 * crc.c 
     3 * 
     4 * $Id: crc.c,v 1.1 2006/02/13 09:58:08 andrzej Exp $ 
     5 * 
     6 * Gary S. Brown's CRC 
     7 * Code based on Gary S. Brown CRC (1986).  
     8 * Generation polynomial is: 
     9 *   X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0  
     10 * 
     11 * Copyright (C) 2006 Ekiert sp z o.o. 
     12 * Author: Andrzej Ekiert <a.ekiert@ekiert.com> 
     13 * 
     14 * This program is free software; you can redistribute it and/or 
     15 * modify it under the terms of the GNU General Public License 
     16 * as published by the Free Software Foundation; either version 
     17 * 2 of the License, or (at your option) any later version.  
     18 */ 
     19 
     20#include <stdint.h> 
     21 
     22#include "crc.h" 
     23 
     24static const cyg_uint32 crc32_tab[] = { 
     25      0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, 
     26      0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, 
     27      0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 
     28      0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, 
     29      0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, 
     30      0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, 
     31      0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 
     32      0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, 
     33      0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, 
     34      0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, 
     35      0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 
     36      0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, 
     37      0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, 
     38      0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, 
     39      0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 
     40      0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, 
     41      0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, 
     42      0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, 
     43      0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 
     44      0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, 
     45      0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, 
     46      0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, 
     47      0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, 
     48      0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, 
     49      0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, 
     50      0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, 
     51      0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, 
     52      0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, 
     53      0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, 
     54      0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, 
     55      0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 
     56      0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, 
     57      0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, 
     58      0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, 
     59      0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 
     60      0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, 
     61      0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, 
     62      0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, 
     63      0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 
     64      0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, 
     65      0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, 
     66      0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, 
     67      0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 
     68      0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, 
     69      0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, 
     70      0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, 
     71      0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 
     72      0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, 
     73      0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, 
     74      0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, 
     75      0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 
     76      0x2d02ef8dL 
     77   }; 
     78 
     79/* This is the standard Gary S. Brown's 32 bit CRC algorithm, but 
     80   accumulate the CRC into the result of a previous CRC. */ 
     81cyg_uint32  
     82cyg_crc32_accumulate(cyg_uint32 crc32val, unsigned char *s, int len) 
     83{ 
     84  int i; 
     85 
     86  for (i = 0;  i < len;  i++) { 
     87    crc32val = crc32_tab[(crc32val ^ s[i]) & 0xff] ^ (crc32val >> 8); 
     88  } 
     89  return crc32val; 
     90} 
     91 
     92/* This is the standard Gary S. Brown's 32 bit CRC algorithm */ 
     93cyg_uint32 
     94cyg_crc32(unsigned char *s, int len) 
     95{ 
     96  return (cyg_crc32_accumulate(0,s,len)); 
     97} 
     98 
  • image/uboot-dt2/src/debug.d

    Property changes on: image/uboot-dt2/src/crc.c
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1debug.o debug.d : debug.c /usr/include/stdio.h /usr/include/features.h \ 
     2  /usr/include/sys/cdefs.h /usr/include/bits/wordsize.h \ 
     3  /usr/include/gnu/stubs.h /usr/include/gnu/stubs-32.h \ 
     4  /usr/lib/gcc/i386-redhat-linux/4.3.2/include/stddef.h \ 
     5  /usr/include/bits/types.h /usr/include/bits/typesizes.h \ 
     6  /usr/include/libio.h /usr/include/_G_config.h /usr/include/wchar.h \ 
     7  /usr/lib/gcc/i386-redhat-linux/4.3.2/include/stdarg.h \ 
     8  /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h debug.h \ 
     9  /usr/include/stdint.h /usr/include/bits/wchar.h 
  • image/uboot-dt2/src/crc.d

    Property changes on: image/uboot-dt2/src/debug.d
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1crc.o crc.d : crc.c /usr/include/stdint.h /usr/include/features.h \ 
     2  /usr/include/sys/cdefs.h /usr/include/bits/wordsize.h \ 
     3  /usr/include/gnu/stubs.h /usr/include/gnu/stubs-32.h \ 
     4  /usr/include/bits/wchar.h crc.h 
  • image/uboot-dt2/src/debug.h

    Property changes on: image/uboot-dt2/src/crc.d
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1/* 
     2 * debug.h 
     3 * 
     4 * $Id: debug.h,v 1.1 2006/02/13 09:58:08 andrzej Exp $ 
     5 * 
     6 * Redboot Flash Configuration parser.  
     7 * Debug utilities - header.  
     8 * 
     9 * Copyright (C) 2006 Ekiert sp z o.o. 
     10 * Author: Andrzej Ekiert <a.ekiert@ekiert.com> 
     11 * 
     12 * This program is free software; you can redistribute it and/or 
     13 * modify it under the terms of the GNU General Public License 
     14 * as published by the Free Software Foundation; either version 
     15 * 2 of the License, or (at your option) any later version.  
     16 */ 
     17 
     18#ifndef DEBUG_H 
     19#define DEBUG_H 
     20 
     21#include <stdint.h> 
     22 
     23#define VERB_LOW 1 
     24#define VERB_NORMAL 2 
     25#define VERB_HIGH 3 
     26 
     27extern uint8_t verbosity; 
     28 
     29void hex_dump(void *buf, uint16_t len); 
     30 
     31#define MESSAGE(verb, args...) \ 
     32        do { \ 
     33                if (verb <= verbosity) { \ 
     34                        printf(args); \ 
     35                } \ 
     36        } while (0); 
     37 
     38#endif //DEBUG_H 
     39 
  • image/uboot-dt2/src/crunchfc.c

    Property changes on: image/uboot-dt2/src/debug.h
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1#include <stdio.h> 
     2#include <stdlib.h> 
     3#include <stdint.h> 
     4#include <stddef.h> 
     5#include <string.h> 
     6#include <errno.h> 
     7#include <unistd.h> 
     8 
     9#include "crunchfc.h" 
     10#include "crc.h" 
     11#include "debug.h" 
     12 
     13/* 
     14 * List known keys. 
     15 */ 
     16int8_t list_keys(struct config_data *data) 
     17{ 
     18        unsigned char *Command = data->buf + 4; 
     19 
     20        while(*Command) { 
     21                printf("%s\n", Command); 
     22                Command += strlen(Command) + 1; 
     23        } 
     24} 
     25 
     26/* 
     27 * Find a key with given nickname and print value 
     28 */ 
     29int8_t get_key_value(struct config_data *data, uint8_t *nickname) 
     30{ 
     31        unsigned char *Command = data->buf + 4; 
     32        int i = strlen(nickname); 
     33 
     34        while(*Command) { 
     35                if (strncmp(Command, nickname, i) == 0) { 
     36                        Command += i + 1; 
     37                        printf("%s\n", Command); 
     38                        break; 
     39                } 
     40                Command += strlen(Command) + 1; 
     41        } 
     42} 
     43 
     44/* 
     45 * Find a key with given nickname and set value 
     46 */ 
     47int8_t set_key_value(struct config_data *data, uint8_t *nickname, void *value) 
     48{ 
     49        int i = strlen(nickname); 
     50        unsigned char *p, *pe, *Command = data->buf + 4; 
     51 
     52        while(*Command) { 
     53                if (strncmp(Command, nickname, i) == 0) { 
     54                        break; 
     55                } 
     56                Command += strlen(Command) + 1; 
     57        } 
     58        // "Command" still points to nickname. 
     59        p = Command; 
     60 
     61        while(*p)   // search end of environment 
     62                p += strlen(p) + 1; 
     63        strncpy(p, Command, i + 1);  // copy nickname to the end 
     64 
     65        p += strlen(p); // set nickname value 
     66        strcpy(p, (unsigned char *)value); 
     67 
     68        p += strlen(p) + 1; 
     69        *p = 0;  // end flag 
     70 
     71        pe = Command + strlen(Command) + 1; 
     72        while(pe <= p)      // erase old nickname 
     73                *(Command++) = *(pe++); 
     74        while(Command <= p) // erase garbage 
     75                *(Command++) = 0; 
     76 
     77        return 0; 
     78} 
  • image/uboot-dt2/src/crc.h

    Property changes on: image/uboot-dt2/src/crunchfc.c
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1#ifndef CRC_H 
     2#define CRC_H 
     3 
     4#include <stdint.h> 
     5 
     6typedef unsigned int cyg_uint32; 
     7cyg_uint32 cyg_crc32(unsigned char *s, int len); 
     8cyg_uint32 cyg_crc32_accumulate(cyg_uint32, unsigned char*, int); 
     9 
     10#endif //CRC_H 
     11 
  • image/uboot-dt2/src/crunchfc.d

    Property changes on: image/uboot-dt2/src/crc.h
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1crunchfc.o crunchfc.d : crunchfc.c /usr/include/stdio.h /usr/include/features.h \ 
     2  /usr/include/sys/cdefs.h /usr/include/bits/wordsize.h \ 
     3  /usr/include/gnu/stubs.h /usr/include/gnu/stubs-32.h \ 
     4  /usr/lib/gcc/i386-redhat-linux/4.3.2/include/stddef.h \ 
     5  /usr/include/bits/types.h /usr/include/bits/typesizes.h \ 
     6  /usr/include/libio.h /usr/include/_G_config.h /usr/include/wchar.h \ 
     7  /usr/lib/gcc/i386-redhat-linux/4.3.2/include/stdarg.h \ 
     8  /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \ 
     9  /usr/include/stdlib.h /usr/include/sys/types.h /usr/include/time.h \ 
     10  /usr/include/endian.h /usr/include/bits/endian.h \ 
     11  /usr/include/bits/byteswap.h /usr/include/sys/select.h \ 
     12  /usr/include/bits/select.h /usr/include/bits/sigset.h \ 
     13  /usr/include/bits/time.h /usr/include/sys/sysmacros.h \ 
     14  /usr/include/bits/pthreadtypes.h /usr/include/alloca.h \ 
     15  /usr/include/stdint.h /usr/include/bits/wchar.h /usr/include/string.h \ 
     16  /usr/include/errno.h /usr/include/bits/errno.h \ 
     17  /usr/include/linux/errno.h /usr/include/asm/errno.h \ 
     18  /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ 
     19  /usr/include/unistd.h /usr/include/bits/posix_opt.h \ 
     20  /usr/include/bits/confname.h /usr/include/getopt.h crunchfc.h crc.h \ 
     21  debug.h 
  • image/uboot-dt2/src/Makefile

    Property changes on: image/uboot-dt2/src/crunchfc.d
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1NAME = uboot-dt2 
     2SRC = uboot-dt2.c debug.c crc.c crunchfc.c 
     3OBJ = $(subst .c,.o, $(SRC)) 
     4 
     5all: $(NAME) 
     6 
     7%.d: %.c 
     8        $(SHELL) -ec '$(CC) -M $(CPPFLAGS) $< \ 
     9                | sed '\''s/\($*\)\.o[ :]*/\1.o $@ : /g'\'' > $@; \ 
     10                [ -s $@ ] || rm -f $@' 
     11 
     12ifneq ($(MAKECMDGOALS), clean) 
     13-include $(SRC:.c=.d) 
     14endif 
     15 
     16$(NAME): $(OBJ) 
     17        $(CC) $(LDFLAGS) -o $@ $(OBJ) $(LDLIBS) 
     18 
     19clean: 
     20        -rm -f $(NAME) *.d *.o 
     21 
  • image/uboot-dt2/Makefile

    Property changes on: image/uboot-dt2/src/Makefile
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1#  
     2# Copyright (C) 2006 OpenWrt.org 
     3# 
     4# This is free software, licensed under the GNU General Public License v2. 
     5# See /LICENSE for more information. 
     6# 
     7 
     8include $(TOPDIR)/rules.mk 
     9 
     10PKG_NAME := uboot-dt2 
     11PKG_BUILD_DIR := $(BUILD_DIR)/$(PKG_NAME) 
     12 
     13$(PKG_BUILD_DIR)/.prepared: 
     14        mkdir $(PKG_BUILD_DIR) 
     15        $(CP) ./src/* $(PKG_BUILD_DIR)/ 
     16        touch $@ 
     17 
     18$(PKG_BUILD_DIR)/uboot-dt2: $(PKG_BUILD_DIR)/.prepared 
     19        $(MAKE) -C $(PKG_BUILD_DIR) CC="$(TARGET_CC)" \ 
     20                LD="$(TARGET_CROSS)ld" CROSS_COMPILE="$(TARGET_CROSS)" 
     21 
     22download:  
     23prepare: $(PKG_BUILD_DIR)/.prepared 
     24compile: $(PKG_BUILD_DIR)/uboot-dt2 
     25install: 
     26 
     27ifneq ($(TARGET),) 
     28install: compile 
     29        $(CP) $(PKG_BUILD_DIR)/uboot-dt2 $(TARGET)/ 
     30endif 
     31 
     32clean: 
     33        rm -rf $(PKG_BUILD_DIR) 
  • image/decodefw-dt2/src/decodefw-dt2.c

    Property changes on: image/uboot-dt2/Makefile
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1#include <stdio.h> 
     2#include <stdlib.h> 
     3#include <string.h> 
     4#include <sys/stat.h> 
     5#include <fcntl.h> 
     6#include <stdint.h> 
     7#include <getopt.h> 
     8 
     9#define maxLen 1024  
     10 
     11// ******************************************************************* 
     12// CCITT polynom G(x)=x^16+x^12+x^5+1 
     13#define POLYNOM  0x1021 
     14 
     15// CRC algorithm with MSB first 
     16int make_crc16(int crc, char new) 
     17{ 
     18        int i; 
     19        crc = crc ^ (((int)new) << 8); 
     20   
     21        for(i=0; i<8; i++) {  // work on 8 bits in "new" 
     22                crc <<= 1;          // MSBs first 
     23                if(crc & 0x10000)  crc ^= POLYNOM; 
     24        } 
     25        return crc & 0xFFFF; 
     26} 
     27 
     28// ******************************************************************* 
     29// Reads the file "filename" into memory and returns pointer to the buffer. 
     30static char *readfile(char *filename, int *size) 
     31{ 
     32        FILE            *fp; 
     33        char            *buffer; 
     34        struct stat     info; 
     35         
     36        if (stat(filename,&info)!=0) 
     37                return NULL; 
     38 
     39        if ((fp=fopen(filename,"r"))==NULL) 
     40                return NULL; 
     41 
     42        buffer=NULL; 
     43        for (;;) 
     44        { 
     45                if ((buffer=(char *)malloc(info.st_size+1))==NULL) 
     46                        break; 
     47 
     48                if (fread(buffer,1,info.st_size,fp)!=info.st_size) 
     49                { 
     50                        free(buffer); 
     51                        buffer=NULL; 
     52                        break; 
     53                } 
     54 
     55                buffer[info.st_size]='\0'; 
     56                if(size) *size = info.st_size; 
     57 
     58                break; 
     59        } 
     60 
     61        (void)fclose(fp); 
     62 
     63        return buffer; 
     64} 
     65 
     66static int decode_firmware(uint8_t *sfilename, uint8_t *dfilename) 
     67{ 
     68        int count;  // size of file in bytes 
     69        char *p, *master = readfile(sfilename, &count); 
     70        if(!master) { 
     71                fputs("ERROR: Firmaware file not found!\n", stdout); 
     72                return 1; 
     73        } 
     74        free(master); 
     75 
     76        short crc16; 
     77        short devFlag; 
     78        int i, len = count-2; 
     79        char Buffer[maxLen]; 
     80        char tmp; 
     81        int z, crc = 0xFFFF; 
     82 
     83        FILE *File1 = fopen(sfilename, "r"); 
     84 
     85        fread (&devFlag, 1, sizeof(short), File1);      // read CRC/Magic number 
     86        fread (&crc16, 1, sizeof(short), File1);        // read CRC 
     87        short crcEnc = crc16; 
     88 
     89        int File = open(dfilename, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR); 
     90 
     91        while(len > 0) { 
     92                if(len > maxLen)  i = maxLen; 
     93                else i = len; 
     94                i = fread (Buffer, 1, i, File1);        // read and write in blocks 
     95                for(z=0; z<i; z++) { 
     96                        tmp = Buffer[z]; 
     97                        Buffer[z] ^= (char)crcEnc;      // decode data 
     98                        crcEnc = tmp; 
     99                        crc = make_crc16(crc, Buffer[z]);       // calculate CRC 
     100                } 
     101                i = write(File, Buffer, i); 
     102                if(i <= 0)  goto EndProgram;            // "Result" is still 1. 
     103                len -= i; 
     104        } 
     105 
     106EndProgram: 
     107 
     108        close(File1); 
     109 
     110        return 0; 
     111} 
     112 
     113/* 
     114 * Print usage information. 
     115 */ 
     116static void usage(void) 
     117{ 
     118        fputs("Freecom DataTank firmware decode utility\n", stdout); 
     119        fputs("usage: decodefw-dt2 -s -d\n", stdout); 
     120        fputs(" -s:\tfirmware image\n", stdout); 
     121        fputs(" -d:\tdestination archive\n", stdout); 
     122} 
     123 
     124/* 
     125 * main(). 
     126 */ 
     127int main(int argc, char **argv) 
     128{ 
     129        int c, ret; 
     130        uint8_t *sfilename = NULL; 
     131        uint8_t *dfilename = NULL; 
     132 
     133        while ((c = getopt(argc, argv, "h:s:d:")) != -1) { 
     134                switch (c) { 
     135                case 's': 
     136                        sfilename = optarg; 
     137                        break; 
     138                case 'd': 
     139                        dfilename = optarg; 
     140                        break; 
     141                case 'h': 
     142                        usage(); 
     143                        break; 
     144                case '?': 
     145                default: 
     146                        usage(); 
     147                        exit(1); 
     148                        break; 
     149                } 
     150        } 
     151 
     152        if (sfilename == NULL) { 
     153                fputs("You must provide the firmware filename\n", stdout); 
     154                usage(); 
     155                exit(1); 
     156        } 
     157 
     158        if (dfilename == NULL) { 
     159                fputs("You must provide the target archive filename\n", stdout); 
     160                usage(); 
     161                exit(1); 
     162        } 
     163 
     164        ret = decode_firmware(sfilename, dfilename); 
     165 
     166        return ret; 
     167} 
  • image/decodefw-dt2/src/Makefile

    Property changes on: image/decodefw-dt2/src/decodefw-dt2.c
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1NAME = decodefw-dt2 
     2SRC = decodefw-dt2.c 
     3OBJ = $(subst .c,.o, $(SRC)) 
     4 
     5all: $(NAME) 
     6 
     7%.d: %.c 
     8        $(SHELL) -ec '$(CC) -M $(CPPFLAGS) $< \ 
     9                | sed '\''s/\($*\)\.o[ :]*/\1.o $@ : /g'\'' > $@; \ 
     10                [ -s $@ ] || rm -f $@' 
     11 
     12ifneq ($(MAKECMDGOALS), clean) 
     13-include $(SRC:.c=.d) 
     14endif 
     15 
     16$(NAME): $(OBJ) 
     17        $(CC) $(LDFLAGS) -o $@ $(OBJ) $(LDLIBS) 
     18 
     19clean: 
     20        -rm -f $(NAME) *.d *.o 
     21 
  • image/decodefw-dt2/Makefile

    Property changes on: image/decodefw-dt2/src/Makefile
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1#  
     2# Copyright (C) 2006 OpenWrt.org 
     3# 
     4# This is free software, licensed under the GNU General Public License v2. 
     5# See /LICENSE for more information. 
     6# 
     7 
     8include $(TOPDIR)/rules.mk 
     9 
     10PKG_NAME := decodefw-dt2 
     11PKG_BUILD_DIR := $(BUILD_DIR)/$(PKG_NAME) 
     12 
     13$(PKG_BUILD_DIR)/.prepared: 
     14        mkdir $(PKG_BUILD_DIR) 
     15        $(CP) ./src/* $(PKG_BUILD_DIR)/ 
     16        touch $@ 
     17 
     18$(PKG_BUILD_DIR)/decodefw-dt2: $(PKG_BUILD_DIR)/.prepared 
     19        $(MAKE) -C $(PKG_BUILD_DIR) CC="$(TARGET_CC)" \ 
     20                LD="$(TARGET_CROSS)ld" CROSS_COMPILE="$(TARGET_CROSS)" 
     21 
     22download:  
     23prepare: $(PKG_BUILD_DIR)/.prepared 
     24compile: $(PKG_BUILD_DIR)/decodefw-dt2 
     25install: 
     26 
     27ifneq ($(TARGET),) 
     28install: compile 
     29        $(CP) $(PKG_BUILD_DIR)/decodefw-dt2 $(TARGET)/ 
     30endif 
     31 
     32clean: 
     33        rm -rf $(PKG_BUILD_DIR) 
  • harddisk/profiles/100-DT2.mk

    Property changes on: image/decodefw-dt2/Makefile
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1# 
     2# Copyright (C) 2009 OpenWrt.org 
     3# 
     4# This is free software, licensed under the GNU General Public License v2. 
     5# See /LICENSE for more information. 
     6# 
     7 
     8define Profile/DT2 
     9  NAME:=Freecom DT2 
     10  PACKAGES:=fand block-mount 
     11endef 
     12 
     13define Profile/DT2/Description 
     14        Package set optimized for the Freecom DT2 
     15endef 
     16 
     17$(eval $(call Profile,DT2)) 
     18 
  • harddisk/config-default

    Property changes on: harddisk/profiles/100-DT2.mk
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1CONFIG_CMDLINE_FROM_BOOTLOADER=y 
    12CONFIG_ATA=y 
    23CONFIG_BLK_DEV_DM=y 
    34CONFIG_BLK_DEV_MD=y 
     
    1011# CONFIG_DM_SNAPSHOT is not set 
    1112# CONFIG_DM_UEVENT is not set 
    1213# CONFIG_DM_ZERO is not set 
    13 CONFIG_EXT4_FS=y 
     14CONFIG_EXT3_FS=y 
    1415CONFIG_JBD=y 
    1516CONFIG_LBD=y 
    1617CONFIG_MD_AUTODETECT=y 
     
    3233CONFIG_USB_EHCI_TT_NEWSCHED=y 
    3334CONFIG_USB_STORAGE=y 
    3435CONFIG_USB=y 
     36CONFIG_MTD_JEDECPROBE=y 
     37# CONFIG_MTD_IMPA7 is not set 
     38# CONFIG_ORION_WATCHDOG is not set 
     39CONFIG_LEDS_TRIGGER_NETDEV=y 
     40CONFIG_LEDS_DT2=y 
     41CONFIG_SENSORS_DT2=y 
     42CONFIG_INPUT=y 
     43CONFIG_INPUT_MISC=y 
     44CONFIG_INPUT_BUTTONS_DT2=y 
     45CONFIG_BINFMT_MISC=y 
     46# CONFIG_MACH_D2NET is not set 
     47# CONFIG_MACH_BIGDISK is not set 
     48# CONFIG_MACH_NET2BIG is not set 
     49# CONFIG_MACH_WNR854T is not set 
     50# CONFIG_MACH_WRT350N_V2 is not set 
     51CONFIG_CRYPTO_HW=y 
     52CONFIG_CRYPTO_DEV_MV_CESA=y 
     53CONFIG_LBDAF=y 
     54# CONFIG_JFFS2_FS is not set 
     55# CONFIG_SQUASHFS is not set 
     56# CONFIG_MINI_FO is not set 
  • harddisk/base-files/lib/upgrade/platform.sh

     
     1USE_REFRESH=1 
     2 
     3MTD_BIN=/tmp/mtd0.bin 
     4UBOOT_CONFIG=/dev/mtd0 
     5DECODED_FW=/tmp/.update 
     6 
     7NEW_ROOTFS_DIR=/tmp/update 
     8 
     9platform_check_image() { 
     10        [ "$ARGC" -gt 1 ] && return 1 
     11 
     12        case "$(get_magic_word "$1")" in 
     13                4454) return 0;; 
     14                *) 
     15                        echo "Invalid image type" 
     16                        return 1 
     17                ;; 
     18        esac 
     19} 
     20 
     21platform_do_upgrade() { 
     22        #mount new root partition 
     23        NEWROOTDEV=$(cat /proc/cmdline | cut -d" " -f2 | cut -d= -f2) 
     24        NEWROOTDEV=${NEWROOTDEV:7:1} 
     25        if  [ $NEWROOTDEV == 1 ]; then 
     26                NEWROOTDEV=0 
     27        else 
     28                NEWROOTDEV=1 
     29        fi 
     30        v "Mount new rootfs partition /dev/md$NEWROOTDEV at $NEW_ROOTFS_DIR..." 
     31        mkdir $NEW_ROOTFS_DIR 
     32        mount /dev/md$NEWROOTDEV $NEW_ROOTFS_DIR 
     33 
     34        #extract firmware 
     35        v "Decode firmware at $DECODED_FW..." 
     36        decodefw-dt2 -s "$1" -d $DECODED_FW 
     37        rm -R $NEW_ROOTFS_DIR/* 
     38        cd $NEW_ROOTFS_DIR 
     39        tar -xj -f $DECODED_FW 
     40        rm -f $DECODED_FW 
     41         
     42        #write new boot info at u-boot config 
     43        v "Write new u-boot config..." 
     44        dd if=$UBOOT_CONFIG of=$MTD_BIN 
     45        uboot-dt2 -s -w -d $MTD_BIN -n bootargs_root -x "root=/dev/md$NEWROOTDEV rw" 
     46        NEWROOTDEV=`expr $NEWROOTDEV + 1` 
     47        uboot-dt2 -s -w -d $MTD_BIN -n bootpartition -x $NEWROOTDEV 
     48        mtd -e $UBOOT_CONFIG write $MTD_BIN $UBOOT_CONFIG 
     49         
     50        return 0 
     51} 
     52 
     53platform_refresh_partitions() { 
     54        return 0 
     55} 
     56 
     57platform_copy_config() { 
     58        v "Save config archive $CONF_TAR at $NEW_ROOTFS_DIR..." 
     59        cp $CONF_TAR $NEW_ROOTFS_DIR 
     60 
     61        return 0 
     62} 
     63 
     64set_extra_copy_bin() { 
     65        RAMFS_COPY_BIN="/bin/gzip /bin/tar /bin/mkdir /bin/rm /usr/bin/bzip2 /usr/bin/cut /usr/bin/expr /usr/bin/uboot-dt2 /usr/bin/decodefw-dt2" 
     66 
     67        v "extra programs for temporary ramfs root: $RAMFS_COPY_BIN" 
     68        export RAMFS_COPY_BIN 
     69} 
     70 
     71append sysupgrade_pre_upgrade set_extra_copy_bin 
  • harddisk/base-files/lib/preinit/10_mount_hdd

    Property changes on: harddisk/base-files/lib/upgrade/platform.sh
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1#!/bin/sh 
     2# Copyright (C) 2010 www.abcsolutions.lv 
     3 
     4get_root_dev() { 
     5    pi_root_dev=$(cat /proc/cmdline | cut -d" " -f2 | cut -d= -f2) 
     6} 
     7 
     8do_mount_root_hdd() { 
     9    get_root_dev 
     10    mount -o remount,rw,noatime,nodiratime $pi_root_dev / 
     11}    
     12 
     13boot_hook_add preinit_mount_root do_mount_root_hdd 
     14 
  • harddisk/base-files/etc/hotplug.d/button/00-button

    Property changes on: harddisk/base-files/lib/preinit/10_mount_hdd
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1. /etc/functions.sh 
     2do_button () { 
     3        local button 
     4        local action 
     5        local handler 
     6        local min 
     7        local max 
     8 
     9        config_get button $1 button 
     10        config_get action $1 action 
     11        config_get handler $1 handler 
     12        config_get min $1 min 
     13        config_get max $1 max 
     14         
     15        [ "$ACTION" = "$action" -a "$BUTTON" = "$button" -a -n "$handler" ] && { 
     16                [ -z "$min" -o -z "$max" ] && eval $handler  
     17                [ -n "$min" -a -n "$max" ] && { 
     18                        [ $min -le $SEEN -a $max -ge $SEEN ] && eval $handler  
     19                } 
     20        } 
     21} 
     22 
     23config_load system 
     24config_foreach do_button button 
  • harddisk/base-files/etc/init.d/satasw

    Property changes on: harddisk/base-files/etc/hotplug.d/button/00-button
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1#!/bin/sh /etc/rc.common 
     2# Copyright (C) 2009 OpenWrt.org 
     3 
     4STOP=99 
     5 
     6stop() { 
     7        [ -f /sys/class/leds/dt2:blue:satasw/brightness ] && { 
     8                echo 0 > /sys/class/leds/dt2:blue:satasw/brightness 
     9        } 
     10} 
     11 
  • harddisk/base-files/etc/config/fstab

    Property changes on: harddisk/base-files/etc/init.d/satasw
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1config global automount 
     2        option from_fstab 0 
     3        option anon_mount 1 
     4         
     5config global autoswap 
     6        option from_fstab 0 
     7        option anon_swap 0 
     8         
     9config mount 
     10        option target   /home 
     11        option device   /dev/md3 
     12        option fstype   ext3 
     13        option options  rw,sync 
     14        option enabled  1 
     15        option enabled_fsck 0 
     16 
     17config swap 
     18        option device   /dev/md2 
     19        option enabled  1 
     20 
  • harddisk/base-files/etc/config/system

    Property changes on: harddisk/base-files/etc/config/fstab
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
     1config system 
     2        option hostname OpenWrt 
     3        option timezone UTC 
     4 
     5config button 
     6        option button   power 
     7        option action   released 
     8        option handler  "reboot" 
     9        option min      0 
     10        option max      4 
     11 
     12config button 
     13        option button   power 
     14        option action   released 
     15        option handler  "halt" 
     16        option min      5 
     17        option max      30 
     18 
     19config led 
     20        option name     wan 
     21        option sysfs    dt2:blue:wan 
     22        option default  1 
     23        option trigger  netdev 
     24        option dev      wan 
     25        option mode     link 
     26 
     27config led 
     28        option name     wlan 
     29        option sysfs    dt2:blue:wlan 
     30        option default  1 
     31        option trigger  netdev 
     32        option dev      wifi0 
     33        option mode     link 
     34 
     35config led 
     36        option name     satahw 
     37        option sysfs    dt2:blue:satahw 
     38        option default  1 
     39 
     40config led 
     41        option name     satasw 
     42        option sysfs    dt2:blue:satasw 
     43        option default  1 
     44 
     45config led 
     46        option name     power 
     47        option sysfs    dt2:blue:power 
     48        option default  0 
     49 
     50config led 
     51        option name     sync 
     52        option sysfs    dt2:blue:sync 
     53        option default  0 
     54 
     55config led 
     56        option name     usb1 
     57        option sysfs    dt2:blue:usb1 
     58        option default  0 
     59 
     60config led 
     61        option name     usb2 
     62        option sysfs    dt2:blue:usb2 
     63        option default  0 
  • harddisk/target.mk

    Property changes on: harddisk/base-files/etc/config/system
    ___________________________________________________________________
    Added: svn:executable
       + *
    
     
    66# 
    77 
    88BOARDNAME:=Internal Hard-Disk 
    9 FEATURES:=targz 
     9FEATURES:=squashfs 
    1010 
    1111define Target/Description 
    1212        Build firmware images for Marvell Orion based boards that boot directly from internal disk storage.