Changeset 30406


Ignore:
Timestamp:
2012-02-10T09:19:33+01:00 (6 years ago)
Author:
juhosg
Message:

ar71xx: merge 3.2 fixes

Location:
trunk/target/linux/ar71xx
Files:
9 deleted
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/ar71xx/files/drivers/leds/leds-rb750.c

    r23975 r30406  
    1010 */ 
    1111#include <linux/kernel.h> 
     12#include <linux/module.h> 
    1213#include <linux/init.h> 
    1314#include <linux/platform_device.h> 
     
    1516#include <linux/slab.h> 
    1617 
    17 #include <asm/mach-ar71xx/mach-rb750.h> 
     18#include <asm/mach-ath79/mach-rb750.h> 
    1819 
    1920#define DRV_NAME        "leds-rb750" 
  • trunk/target/linux/ar71xx/files/drivers/leds/leds-wndr3700-usb.c

    r18758 r30406  
    1313#include <linux/platform_device.h> 
    1414 
    15 #include <asm/mach-ar71xx/ar71xx.h> 
     15#include <asm/mach-ath79/ar71xx_regs.h> 
     16#include <asm/mach-ath79/ath79.h> 
    1617 
    1718#define DRIVER_NAME     "wndr3700-led-usb" 
     
    2122{ 
    2223        if (brightness) 
    23                 ar71xx_device_start(RESET_MODULE_GE1_PHY); 
     24                ath79_device_reset_clear(AR71XX_RESET_GE1_PHY); 
    2425        else 
    25                 ar71xx_device_stop(RESET_MODULE_GE1_PHY); 
     26                ath79_device_reset_set(AR71XX_RESET_GE1_PHY); 
    2627} 
    2728 
    2829static enum led_brightness wndr3700_usb_led_get(struct led_classdev *cdev) 
    2930{ 
    30         return ar71xx_device_stopped(RESET_MODULE_GE1_PHY) ? LED_OFF : LED_FULL; 
     31        return ath79_device_reset_get(AR71XX_RESET_GE1_PHY) ? LED_OFF : LED_FULL; 
    3132} 
    3233 
  • trunk/target/linux/ar71xx/files/drivers/mtd/nand/rb4xx_nand.c

    r29667 r30406  
    1313 */ 
    1414 
     15#include <linux/kernel.h> 
     16#include <linux/module.h> 
    1517#include <linux/init.h> 
    1618#include <linux/mtd/nand.h> 
     
    2325#include <linux/slab.h> 
    2426 
    25 #include <asm/mach-ar71xx/ar71xx.h> 
    26 #include <asm/mach-ar71xx/rb4xx_cpld.h> 
     27#include <asm/mach-ath79/ath79.h> 
     28#include <asm/mach-ath79/rb4xx_cpld.h> 
    2729 
    2830#define DRV_NAME        "rb4xx-nand" 
     
    239241        } 
    240242 
    241 #ifdef CONFIG_MTD_PARTITIONS 
    242         ret = add_mtd_partitions(&info->mtd, rb4xx_nand_partitions, 
     243        mtd_device_register(&info->mtd, rb4xx_nand_partitions, 
    243244                                ARRAY_SIZE(rb4xx_nand_partitions)); 
    244 #else 
    245         ret = add_mtd_device(&info->mtd); 
    246 #endif 
    247245        if (ret) 
    248246                goto err_release_nand; 
  • trunk/target/linux/ar71xx/files/drivers/mtd/nand/rb750_nand.c

    r29667 r30406  
    22 *  NAND flash driver for the MikroTik RouterBOARD 750 
    33 * 
    4  *  Copyright (C) 2010 Gabor Juhos <juhosg@openwrt.org> 
     4 *  Copyright (C) 2010-2012 Gabor Juhos <juhosg@openwrt.org> 
    55 * 
    66 *  This program is free software; you can redistribute it and/or modify it 
     
    99 */ 
    1010 
    11 #include <linux/init.h> 
     11#include <linux/kernel.h> 
     12#include <linux/module.h> 
    1213#include <linux/mtd/nand.h> 
    1314#include <linux/mtd/mtd.h> 
     
    1718#include <linux/slab.h> 
    1819 
    19 #include <asm/mach-ar71xx/ar71xx.h> 
    20 #include <asm/mach-ar71xx/mach-rb750.h> 
     20#include <asm/mach-ath79/ar71xx_regs.h> 
     21#include <asm/mach-ath79/ath79.h> 
     22#include <asm/mach-ath79/mach-rb750.h> 
    2123 
    2224#define DRV_NAME        "rb750-nand" 
     
    7476static void rb750_nand_write(const u8 *buf, unsigned len) 
    7577{ 
    76         void __iomem *base = ar71xx_gpio_base; 
     78        void __iomem *base = ath79_gpio_base; 
    7779        u32 out; 
    7880        u32 t; 
     
    108110                                  const u8 *verify_buf) 
    109111{ 
    110         void __iomem *base = ar71xx_gpio_base; 
     112        void __iomem *base = ath79_gpio_base; 
    111113        unsigned i; 
    112114 
     
    137139static void rb750_nand_select_chip(struct mtd_info *mtd, int chip) 
    138140{ 
    139         void __iomem *base = ar71xx_gpio_base; 
     141        void __iomem *base = ath79_gpio_base; 
    140142        u32 func; 
    141143        u32 t; 
     
    146148                rb750_latch_change(RB750_LVC573_LE, 0); 
    147149 
    148                 /* disable alternate functions */ 
    149                 ar71xx_gpio_function_setup(AR724X_GPIO_FUNC_JTAG_DISABLE, 
    150                                            AR724X_GPIO_FUNC_SPI_EN); 
     150                rb750_nand_pins_enable(); 
    151151 
    152152                /* set input mode for data lines */ 
     
    173173                             base + AR71XX_GPIO_REG_OE); 
    174174 
    175                 /* restore alternate functions */ 
    176                 ar71xx_gpio_function_setup(AR724X_GPIO_FUNC_SPI_EN, 
    177                                            AR724X_GPIO_FUNC_JTAG_DISABLE); 
     175                rb750_nand_pins_disable(); 
    178176 
    179177                /* enable latch */ 
     
    184182static int rb750_nand_dev_ready(struct mtd_info *mtd) 
    185183{ 
    186         void __iomem *base = ar71xx_gpio_base; 
     184        void __iomem *base = ath79_gpio_base; 
    187185 
    188186        return !!(__raw_readl(base + AR71XX_GPIO_REG_IN) & RB750_NAND_RDY); 
     
    193191{ 
    194192        if (ctrl & NAND_CTRL_CHANGE) { 
    195                 void __iomem *base = ar71xx_gpio_base; 
     193                void __iomem *base = ath79_gpio_base; 
    196194                u32 t; 
    197195 
     
    237235static void __init rb750_nand_gpio_init(void) 
    238236{ 
    239         void __iomem *base = ar71xx_gpio_base; 
     237        void __iomem *base = ath79_gpio_base; 
    240238        u32 out; 
    241239        u32 t; 
     
    307305        } 
    308306 
    309 #ifdef CONFIG_MTD_PARTITIONS 
    310         ret = add_mtd_partitions(&info->mtd, rb750_nand_partitions, 
     307        ret = mtd_device_register(&info->mtd, rb750_nand_partitions, 
    311308                                 ARRAY_SIZE(rb750_nand_partitions)); 
    312 #else 
    313         ret = add_mtd_device(&info->mtd); 
    314 #endif 
    315309        if (ret) 
    316310                goto err_release_nand; 
  • trunk/target/linux/ar71xx/files/drivers/mtd/tplinkpart.c

    r29855 r30406  
    109109static int tplink_parse_partitions(struct mtd_info *master, 
    110110                                   struct mtd_partition **pparts, 
    111                                    unsigned long origin) 
     111                                   struct mtd_part_parser_data *data) 
    112112{ 
    113113        struct mtd_partition *parts; 
  • trunk/target/linux/ar71xx/files/drivers/mtd/wrt160nl_part.c

    r29970 r30406  
    8484static int wrt160nl_parse_partitions(struct mtd_info *master, 
    8585                                     struct mtd_partition **pparts, 
    86                                      unsigned long origin) 
     86                                     struct mtd_part_parser_data *data) 
    8787{ 
    8888        struct wrt160nl_header *header; 
  • trunk/target/linux/ar71xx/files/drivers/spi/spi-ap83.c

    r29852 r30406  
    1111 
    1212#include <linux/kernel.h> 
     13#include <linux/module.h> 
    1314#include <linux/init.h> 
    1415#include <linux/delay.h> 
     
    2223#include <linux/gpio.h> 
    2324 
    24 #include <asm/mach-ar71xx/ar71xx.h> 
    25 #include <asm/mach-ar71xx/platform.h> 
     25#include <asm/mach-ath79/ath79.h> 
    2626 
    2727#define DRV_DESC        "Atheros AP83 board SPI Controller driver" 
     
    107107 
    108108        if (on) { 
    109                 ar71xx_flash_acquire(); 
     109                ath79_flash_acquire(); 
    110110 
    111111                sp->addr = 0; 
     
    115115        } else { 
    116116                gpio_set_value(AP83_SPI_GPIO_CS, 1); 
    117                 ar71xx_flash_release(); 
     117                ath79_flash_release(); 
    118118        } 
    119119} 
     
    128128#define EXPAND_BITBANG_TXRX 
    129129#include <linux/spi/spi_bitbang.h> 
    130 #include "spi_bitbang_txrx.h" 
     130#include "spi-bitbang-txrx.h" 
    131131 
    132132static u32 ap83_spi_txrx_mode0(struct spi_device *spi, 
  • trunk/target/linux/ar71xx/files/drivers/spi/spi-rb4xx-cpld.c

    r29851 r30406  
    1414#include <linux/types.h> 
    1515#include <linux/kernel.h> 
     16#include <linux/module.h> 
    1617#include <linux/init.h> 
    1718#include <linux/module.h> 
     
    2223#include <linux/slab.h> 
    2324 
    24 #include <asm/mach-ar71xx/rb4xx_cpld.h> 
     25#include <asm/mach-ath79/rb4xx_cpld.h> 
    2526 
    2627#define DRV_NAME        "spi-rb4xx-cpld" 
  • trunk/target/linux/ar71xx/files/drivers/spi/spi-rb4xx.c

    r29851 r30406  
    1313 */ 
    1414 
     15#include <linux/clk.h> 
     16#include <linux/err.h> 
    1517#include <linux/kernel.h> 
     18#include <linux/module.h> 
    1619#include <linux/init.h> 
    1720#include <linux/delay.h> 
     
    2124#include <linux/spi/spi.h> 
    2225 
    23 #include <asm/mach-ar71xx/ar71xx.h> 
     26#include <asm/mach-ath79/ar71xx_regs.h> 
     27#include <asm/mach-ath79/ath79.h> 
    2428 
    2529#define DRV_NAME        "rb4xx-spi" 
     
    4145        unsigned                spi_ctrl_flash; 
    4246        unsigned                spi_ctrl_fread; 
     47 
     48        struct clk              *ahb_clk; 
     49        unsigned long           ahb_freq; 
    4350 
    4451        spinlock_t              lock; 
     
    4855}; 
    4956 
    50 static unsigned spi_clk_low = SPI_IOC_CS1; 
     57static unsigned spi_clk_low = AR71XX_SPI_IOC_CS1; 
    5158 
    5259#ifdef RB4XX_SPI_DEBUG 
     
    6168static inline void do_spi_init(struct spi_device *spi) 
    6269{ 
    63         unsigned cs = SPI_IOC_CS0 | SPI_IOC_CS1; 
     70        unsigned cs = AR71XX_SPI_IOC_CS0 | AR71XX_SPI_IOC_CS1; 
    6471 
    6572        if (!(spi->mode & SPI_CS_HIGH)) 
    66                 cs ^= (spi->chip_select == 2) ? SPI_IOC_CS1 : SPI_IOC_CS0; 
     73                cs ^= (spi->chip_select == 2) ? AR71XX_SPI_IOC_CS1 : 
     74                                                AR71XX_SPI_IOC_CS0; 
    6775 
    6876        spi_clk_low = cs; 
     
    7280{ 
    7381        do_spi_delay(); 
    74         __raw_writel(SPI_IOC_CS0 | SPI_IOC_CS1, base + SPI_REG_IOC); 
     82        __raw_writel(AR71XX_SPI_IOC_CS0 | AR71XX_SPI_IOC_CS1, 
     83                     base + AR71XX_SPI_REG_IOC); 
    7584} 
    7685 
    7786static inline void do_spi_clk(void __iomem *base, int bit) 
    7887{ 
    79         unsigned bval = spi_clk_low | ((bit & 1) ? SPI_IOC_DO : 0); 
     88        unsigned bval = spi_clk_low | ((bit & 1) ? AR71XX_SPI_IOC_DO : 0); 
    8089 
    8190        do_spi_delay(); 
    82         __raw_writel(bval, base + SPI_REG_IOC); 
     91        __raw_writel(bval, base + AR71XX_SPI_REG_IOC); 
    8392        do_spi_delay(); 
    84         __raw_writel(bval | SPI_IOC_CLK, base + SPI_REG_IOC); 
     93        __raw_writel(bval | AR71XX_SPI_IOC_CLK, base + AR71XX_SPI_REG_IOC); 
    8594} 
    8695 
     
    98107        pr_debug("spi_byte sent 0x%02x got 0x%02x\n", 
    99108               (unsigned)byte, 
    100                (unsigned char)__raw_readl(base + SPI_REG_RDS)); 
     109               (unsigned char)__raw_readl(base + AR71XX_SPI_REG_RDS)); 
    101110} 
    102111 
     
    105114{ 
    106115        unsigned bval = (spi_clk_low | 
    107                          ((bit1 & 1) ? SPI_IOC_DO : 0) | 
    108                          ((bit2 & 1) ? SPI_IOC_CS2 : 0)); 
     116                         ((bit1 & 1) ? AR71XX_SPI_IOC_DO : 0) | 
     117                         ((bit2 & 1) ? AR71XX_SPI_IOC_CS2 : 0)); 
    109118        do_spi_delay(); 
    110         __raw_writel(bval, base + SPI_REG_IOC); 
     119        __raw_writel(bval, base + AR71XX_SPI_REG_IOC); 
    111120        do_spi_delay(); 
    112         __raw_writel(bval | SPI_IOC_CLK, base + SPI_REG_IOC); 
     121        __raw_writel(bval | AR71XX_SPI_IOC_CLK, base + AR71XX_SPI_REG_IOC); 
    113122} 
    114123 
     
    122131        pr_debug("spi_byte_fast sent 0x%02x got 0x%02x\n", 
    123132               (unsigned)byte, 
    124                (unsigned char) __raw_readl(base + SPI_REG_RDS)); 
     133               (unsigned char) __raw_readl(base + AR71XX_SPI_REG_RDS)); 
    125134} 
    126135 
     
    151160 
    152161                if (rx_ptr) { 
    153                         rx_ptr[i] = __raw_readl(base + SPI_REG_RDS) & 0xff; 
     162                        rx_ptr[i] = __raw_readl(base + AR71XX_SPI_REG_RDS) & 0xff; 
    154163                } else if (rxv_ptr) { 
    155                         unsigned char c = __raw_readl(base + SPI_REG_RDS); 
     164                        unsigned char c = __raw_readl(base + AR71XX_SPI_REG_RDS); 
    156165                        if (rxv_ptr[i] != c) 
    157166                                return i; 
     
    202211                return -1; 
    203212 
    204         __raw_writel(SPI_FS_GPIO, base + SPI_REG_FS); 
    205         __raw_writel(rbspi->spi_ctrl_fread, base + SPI_REG_CTRL); 
    206         __raw_writel(0, base + SPI_REG_FS); 
     213        __raw_writel(AR71XX_SPI_FS_GPIO, base + AR71XX_SPI_REG_FS); 
     214        __raw_writel(rbspi->spi_ctrl_fread, base + AR71XX_SPI_REG_CTRL); 
     215        __raw_writel(0, base + AR71XX_SPI_REG_FS); 
    207216 
    208217        if (t->rx_buf) { 
     
    217226 
    218227        if (rbspi->spi_ctrl_flash != rbspi->spi_ctrl_fread) { 
    219                 __raw_writel(SPI_FS_GPIO, base + SPI_REG_FS); 
    220                 __raw_writel(rbspi->spi_ctrl_flash, base + SPI_REG_CTRL); 
    221                 __raw_writel(0, base + SPI_REG_FS); 
     228                __raw_writel(AR71XX_SPI_FS_GPIO, base + AR71XX_SPI_REG_FS); 
     229                __raw_writel(rbspi->spi_ctrl_flash, base + AR71XX_SPI_REG_CTRL); 
     230                __raw_writel(0, base + AR71XX_SPI_REG_FS); 
    222231        } 
    223232 
     
    238247                        return -1; 
    239248 
    240         __raw_writel(SPI_FS_GPIO, base + SPI_REG_FS); 
    241         __raw_writel(SPI_CTRL_FASTEST, base + SPI_REG_CTRL); 
     249        __raw_writel(AR71XX_SPI_FS_GPIO, base + AR71XX_SPI_REG_FS); 
     250        __raw_writel(SPI_CTRL_FASTEST, base + AR71XX_SPI_REG_CTRL); 
    242251        do_spi_init(m->spi); 
    243252 
     
    263272 
    264273        do_spi_finish(base); 
    265         __raw_writel(rbspi->spi_ctrl_flash, base + SPI_REG_CTRL); 
    266         __raw_writel(0, base + SPI_REG_FS); 
     274        __raw_writel(rbspi->spi_ctrl_flash, base + AR71XX_SPI_REG_CTRL); 
     275        __raw_writel(0, base + AR71XX_SPI_REG_FS); 
    267276        return -1; 
    268277} 
     
    353362} 
    354363 
    355 static unsigned get_spi_ctrl(unsigned hz_max, const char *name) 
     364static unsigned get_spi_ctrl(struct rb4xx_spi *rbspi, unsigned hz_max, 
     365                             const char *name) 
    356366{ 
    357367        unsigned div; 
    358368 
    359         div = (ar71xx_ahb_freq - 1) / (2 * hz_max); 
     369        div = (rbspi->ahb_freq - 1) / (2 * hz_max); 
    360370 
    361371        /* 
     
    366376 
    367377        if (name) { 
    368                 unsigned ahb_khz = (ar71xx_ahb_freq + 500) / 1000; 
     378                unsigned ahb_khz = (rbspi->ahb_freq + 500) / 1000; 
    369379                unsigned div_real = 2 * (div + 1); 
    370380                pr_debug("rb4xx: %s SPI clock %u kHz (AHB %u kHz / %u)\n", 
     
    397407 
    398408        rbspi = spi_master_get_devdata(master); 
     409 
     410        rbspi->ahb_clk = clk_get(&pdev->dev, "ahb"); 
     411        if (IS_ERR(rbspi->ahb_clk)) { 
     412                err = PTR_ERR(rbspi->ahb_clk); 
     413                goto err_put_master; 
     414        } 
     415 
     416        err = clk_enable(rbspi->ahb_clk); 
     417        if (err) 
     418                goto err_clk_put; 
     419 
     420        rbspi->ahb_freq = clk_get_rate(rbspi->ahb_clk); 
     421        if (!rbspi->ahb_freq) { 
     422                err = -EINVAL; 
     423                goto err_clk_disable; 
     424        } 
     425 
    399426        platform_set_drvdata(pdev, rbspi); 
    400427 
     
    402429        if (r == NULL) { 
    403430                err = -ENOENT; 
    404                 goto err_put_master; 
     431                goto err_clk_disable; 
    405432        } 
    406433 
     
    408435        if (!rbspi->base) { 
    409436                err = -ENXIO; 
    410                 goto err_put_master; 
     437                goto err_clk_disable; 
    411438        } 
    412439 
    413440        rbspi->master = master; 
    414         rbspi->spi_ctrl_flash = get_spi_ctrl(SPI_FLASH_HZ, "FLASH"); 
    415         rbspi->spi_ctrl_fread = get_spi_ctrl(SPI_CPLD_HZ, "CPLD"); 
     441        rbspi->spi_ctrl_flash = get_spi_ctrl(rbspi, SPI_FLASH_HZ, "FLASH"); 
     442        rbspi->spi_ctrl_fread = get_spi_ctrl(rbspi, SPI_CPLD_HZ, "CPLD"); 
    416443        rbspi->cs_wait = -1; 
    417444 
     
    429456err_iounmap: 
    430457        iounmap(rbspi->base); 
     458err_clk_disable: 
     459        clk_disable(rbspi->ahb_clk); 
     460err_clk_put: 
     461        clk_put(rbspi->ahb_clk); 
    431462err_put_master: 
    432463        platform_set_drvdata(pdev, NULL); 
     
    441472 
    442473        iounmap(rbspi->base); 
     474        clk_disable(rbspi->ahb_clk); 
     475        clk_put(rbspi->ahb_clk); 
    443476        platform_set_drvdata(pdev, NULL); 
    444477        spi_master_put(rbspi->master); 
Note: See TracChangeset for help on using the changeset viewer.