Ticket #6185: 8.09-titan.patch

File 8.09-titan.patch, 22.9 KB (added by Xin Zhen (LoneStar) <xlonestar2000@…>, 8 years ago)

The same patch for 8.09, against the buildroot.

  • target/linux/ar7/patches/920-cpmac_titan.patch

     
     1diff -ruN a/drivers/net/cpmac.c b/drivers/net/cpmac.c 
     2--- a/drivers/net/cpmac.c       2008-11-08 12:06:38.000000000 -0300 
     3+++ b/drivers/net/cpmac.c       2008-11-08 12:09:07.000000000 -0300 
     4@@ -1259,6 +1259,9 @@ 
     5        ar7_device_reset(AR7_RESET_BIT_CPMAC_HI); 
     6        ar7_device_reset(AR7_RESET_BIT_EPHY); 
     7  
     8+       if (ar7_is_titan()) 
     9+               ar7_device_reset(TITAN_RESET_BIT_EPHY1); 
     10+ 
     11        cpmac_mii.reset(&cpmac_mii); 
     12  
     13        for (i = 0; i < 300000; i++) 
     14@@ -1273,7 +1276,11 @@ 
     15                mask = 0; 
     16        } 
     17  
     18-       cpmac_mii.phy_mask = ~(mask | 0x80000000); 
     19+       if (ar7_is_titan()) 
     20+               cpmac_mii.phy_mask = ~(mask | 0x80000000 | 0x40000000); 
     21+       else 
     22+               cpmac_mii.phy_mask = ~(mask | 0x80000000); 
     23+ 
     24        snprintf(cpmac_mii.id, MII_BUS_ID_SIZE, "0"); 
     25  
     26        res = mdiobus_register(&cpmac_mii); 
  • target/linux/ar7/files/include/asm-mips/ar7/ar7.h

     
    4444#define UR8_REGS_WDT    (AR7_REGS_BASE + 0x0b00) 
    4545#define UR8_REGS_UART1  (AR7_REGS_BASE + 0x0f00) 
    4646 
     47#define TITAN_REGS_MAC0         (0x08640000) 
     48#define TITAN_REGS_MAC1         (TITAN_REGS_MAC0 + 0x0800) 
     49#define TITAN_REGS_VLYNQ0       (AR7_REGS_BASE + 0x1c00) 
     50#define TITAN_REGS_VLYNQ1       (AR7_REGS_BASE + 0x1300) 
     51 
    4752#define AR7_RESET_PEREPHERIAL   0x0 
    4853#define AR7_RESET_SOFTWARE      0x4 
    4954#define AR7_RESET_STATUS        0x8 
     
    5358#define AR7_RESET_BIT_MDIO      22 
    5459#define AR7_RESET_BIT_EPHY      26 
    5560 
     61#define TITAN_RESET_BIT_EPHY1   28 
     62 
    5663/* GPIO control registers */ 
    5764#define AR7_GPIO_INPUT  0x0 
    5865#define AR7_GPIO_OUTPUT 0x4 
    5966#define AR7_GPIO_DIR    0x8 
    6067#define AR7_GPIO_ENABLE 0xc 
     68#define TITAN_GPIO_INPUT_0      0x0 
     69#define TITAN_GPIO_INPUT_1      0x4 
     70#define TITAN_GPIO_OUTPUT_0     0x8 
     71#define TITAN_GPIO_OUTPUT_1     0xc 
     72#define TITAN_GPIO_DIR_0        0x10 
     73#define TITAN_GPIO_DIR_1        0x14 
     74#define TITAN_GPIO_ENBL_0       0x18 
     75#define TITAN_GPIO_ENBL_1       0x1c 
    6176 
    6277#define AR7_CHIP_7100   0x18 
    6378#define AR7_CHIP_7200   0x2b 
    6479#define AR7_CHIP_7300   0x05 
     80#define AR7_CHIP_TITAN  0x07 
     81#define TITAN_CHIP_1050 0x0f 
     82#define TITAN_CHIP_1055 0x0e 
     83#define TITAN_CHIP_1056 0x0d 
     84#define TITAN_CHIP_1060 0x07 
    6585 
    6686/* Interrupts */ 
    6787#define AR7_IRQ_UART0   15 
     
    86106 
    87107extern int ar7_cpu_clock, ar7_bus_clock, ar7_dsp_clock; 
    88108 
     109static inline int ar7_is_titan(void) 
     110{ 
     111        return (readl((void *)KSEG1ADDR(AR7_REGS_GPIO + 0x24)) & 0xffff) == 
     112                AR7_CHIP_TITAN; 
     113} 
     114 
    89115static inline u16 ar7_chip_id(void) 
    90116{ 
    91         return readl((void *)KSEG1ADDR(AR7_REGS_GPIO + 0x14)) & 0xffff; 
     117        return ar7_is_titan() ? AR7_CHIP_TITAN : (readl((void *) 
     118                KSEG1ADDR(AR7_REGS_GPIO + 0x14)) & 0xffff); 
    92119} 
    93120 
    94121static inline u8 ar7_chip_rev(void) 
    95122{ 
    96         return (readl((void *)KSEG1ADDR(AR7_REGS_GPIO + 0x14)) >> 16) & 0xff; 
     123        return (readl((void *)KSEG1ADDR(AR7_REGS_GPIO + (ar7_is_titan() ? 0x24 : 
     124                0x14))) >> 16) & 0xff; 
    97125} 
    98126 
    99127static inline int ar7_cpu_freq(void) 
  • target/linux/ar7/files/include/asm-mips/ar7/gpio.h

     
    1919#ifndef __AR7_GPIO_H__ 
    2020#define __AR7_GPIO_H__ 
    2121#include <asm/ar7/ar7.h> 
     22#ifndef __AR7_TITAN_H__ 
     23#include <asm/ar7/titan.h> 
     24#endif 
    2225 
    2326#define AR7_GPIO_MAX 32 
     27#define TITAN_GPIO_MAX 51 
    2428 
    2529extern int gpio_request(unsigned gpio, const char *label); 
    2630extern void gpio_free(unsigned gpio); 
    2731 
    2832/* Common GPIO layer */ 
    29 static inline int gpio_get_value(unsigned gpio) 
     33static inline int gpio_get_value_ar7(unsigned gpio) 
    3034{ 
    3135        void __iomem *gpio_in = 
    3236                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + AR7_GPIO_INPUT); 
     
    3438        return readl(gpio_in) & (1 << gpio); 
    3539} 
    3640 
    37 static inline void gpio_set_value(unsigned gpio, int value) 
     41static inline int gpio_get_value_titan(unsigned gpio) 
    3842{ 
     43        void __iomem *gpio_in0 = 
     44                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_INPUT_0); 
     45        void __iomem *gpio_in1 = 
     46                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_INPUT_1); 
     47 
     48        return readl(gpio >> 5 ? gpio_in1 : gpio_in0) & (1 << (gpio & 0x1f)); 
     49} 
     50 
     51static inline int gpio_get_value(unsigned gpio) 
     52{ 
     53        return ar7_is_titan() ? gpio_get_value_titan(gpio) : 
     54                gpio_get_value_ar7(gpio); 
     55} 
     56 
     57static inline void gpio_set_value_ar7(unsigned gpio, int value) 
     58{ 
    3959        void __iomem *gpio_out = 
    4060                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + AR7_GPIO_OUTPUT); 
    4161        unsigned tmp; 
     
    4666        writel(tmp, gpio_out); 
    4767} 
    4868 
    49 static inline int gpio_direction_input(unsigned gpio) 
     69static inline void gpio_set_value_titan(unsigned gpio, int value) 
    5070{ 
     71        void __iomem *gpio_out0 = 
     72                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_OUTPUT_0); 
     73        void __iomem *gpio_out1 = 
     74                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_OUTPUT_1); 
     75        unsigned tmp; 
     76 
     77        tmp = readl(gpio >> 5 ? gpio_out1 : gpio_out0) & ~(1 << (gpio & 0x1f)); 
     78        if (value) 
     79                tmp |= 1 << (gpio & 0x1f); 
     80        writel(tmp, gpio >> 5 ? gpio_out1 : gpio_out0); 
     81} 
     82 
     83static inline void gpio_set_value(unsigned gpio, int value) 
     84{ 
     85        if (ar7_is_titan()) 
     86                gpio_set_value_titan(gpio, value); 
     87        else 
     88                gpio_set_value_ar7(gpio, value); 
     89} 
     90 
     91static inline int gpio_direction_input_ar7(unsigned gpio) 
     92{ 
    5193        void __iomem *gpio_dir = 
    5294                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + AR7_GPIO_DIR); 
    5395 
     
    59101        return 0; 
    60102} 
    61103 
    62 static inline int gpio_direction_output(unsigned gpio, int value) 
     104static inline int gpio_direction_input_titan(unsigned gpio) 
    63105{ 
     106        void __iomem *gpio_dir0 = 
     107                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_DIR_0); 
     108        void __iomem *gpio_dir1 = 
     109                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_DIR_1); 
     110 
     111        if (gpio >= TITAN_GPIO_MAX) 
     112                return -EINVAL; 
     113 
     114        writel(readl(gpio >> 5 ? gpio_dir1 : gpio_dir0) | (1 << (gpio & 0x1f)), 
     115                gpio >> 5 ? gpio_dir1 : gpio_dir0); 
     116 
     117        return 0; 
     118} 
     119 
     120static inline int gpio_direction_input(unsigned gpio) 
     121{ 
     122        return ar7_is_titan() ?  gpio_direction_input_titan(gpio) : 
     123                gpio_direction_input_ar7(gpio); 
     124} 
     125 
     126static inline int gpio_direction_output_ar7(unsigned gpio, int value) 
     127{ 
    64128        void __iomem *gpio_dir = 
    65129                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + AR7_GPIO_DIR); 
    66130 
     
    73137        return 0; 
    74138} 
    75139 
     140static inline int gpio_direction_output_titan(unsigned gpio, int value) 
     141{ 
     142        void __iomem *gpio_dir0 = 
     143                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_DIR_0); 
     144        void __iomem *gpio_dir1 = 
     145                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_DIR_1); 
     146 
     147        if (gpio >= TITAN_GPIO_MAX) 
     148                return -EINVAL; 
     149 
     150        gpio_set_value_titan(gpio, value); 
     151        writel(readl(gpio >> 5 ? gpio_dir1 : gpio_dir0) & ~(1 << 
     152                (gpio & 0x1f)), gpio >> 5 ? gpio_dir1 : gpio_dir0); 
     153 
     154        return 0; 
     155} 
     156 
     157static inline int gpio_direction_output(unsigned gpio, int value) 
     158{ 
     159        return ar7_is_titan() ?  gpio_direction_output_titan(gpio, value) : 
     160                gpio_direction_output_ar7(gpio, value); 
     161} 
     162 
    76163static inline int gpio_to_irq(unsigned gpio) 
    77164{ 
    78165        return -EINVAL; 
     
    84171} 
    85172 
    86173/* Board specific GPIO functions */ 
    87 static inline int ar7_gpio_enable(unsigned gpio) 
     174static inline int ar7_gpio_enable_ar7(unsigned gpio) 
    88175{ 
    89176        void __iomem *gpio_en = 
    90177                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + AR7_GPIO_ENABLE); 
     
    94181        return 0; 
    95182} 
    96183 
    97 static inline int ar7_gpio_disable(unsigned gpio) 
     184static inline int ar7_gpio_enable_titan(unsigned gpio) 
    98185{ 
     186        void __iomem *gpio_en0 = 
     187                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_ENBL_0); 
     188        void __iomem *gpio_en1 = 
     189                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_ENBL_1); 
     190 
     191        writel(readl(gpio >> 5 ? gpio_en1 : gpio_en0) | (1 << (gpio & 0x1f)), 
     192                gpio >> 5 ? gpio_en1 : gpio_en0); 
     193 
     194        return 0; 
     195} 
     196 
     197static inline int ar7_gpio_enable(unsigned gpio) 
     198{ 
     199        return ar7_is_titan() ? ar7_gpio_enable_titan(gpio) : 
     200                ar7_gpio_enable_ar7(gpio); 
     201} 
     202 
     203static inline int ar7_gpio_disable_ar7(unsigned gpio) 
     204{ 
    99205        void __iomem *gpio_en = 
    100206                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + AR7_GPIO_ENABLE); 
    101207 
     
    104210        return 0; 
    105211} 
    106212 
     213static inline int ar7_gpio_disable_titan(unsigned gpio) 
     214{ 
     215        void __iomem *gpio_en0 = 
     216                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_ENBL_0); 
     217        void __iomem *gpio_en1 = 
     218                (void __iomem *)KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_ENBL_1); 
     219 
     220        writel(readl(gpio >> 5 ? gpio_en1 : gpio_en0) & ~(1 << (gpio & 0x1f)), 
     221                gpio >> 5 ? gpio_en1 : gpio_en0); 
     222 
     223        return 0; 
     224} 
     225 
     226static inline int ar7_gpio_disable(unsigned gpio) 
     227{ 
     228        return ar7_is_titan() ? ar7_gpio_disable_titan(gpio) : 
     229                ar7_gpio_disable_ar7(gpio); 
     230} 
     231 
     232static inline int ar7_init_titan_variant( void ) 
     233{ 
     234        /*UINT32 new_val;*/ 
     235        unsigned new_val; 
     236 
     237        /* set GPIO 44 - 47 as input */ 
     238        /*PAL_sysGpioCtrl(const int, GPIO_PIN, GPIO_INPUT_PIN); */ 
     239        /*define titan_gpio_ctrl in titan.h*/ 
     240        titan_gpio_ctrl(44, GPIO_PIN, GPIO_INPUT_PIN); 
     241        titan_gpio_ctrl(45, GPIO_PIN, GPIO_INPUT_PIN); 
     242        titan_gpio_ctrl(46, GPIO_PIN, GPIO_INPUT_PIN); 
     243        titan_gpio_ctrl(47, GPIO_PIN, GPIO_INPUT_PIN); 
     244     
     245        /* read GPIO to get Titan variant type */ 
     246        /*fix this*/ 
     247        titan_sysGpioInValue( &new_val, 1 ); 
     248 
     249        new_val >>= 12; 
     250        new_val &= 0x0f; 
     251 
     252        switch ( new_val ) 
     253        { 
     254        case TITAN_CHIP_1050: 
     255        case TITAN_CHIP_1055: 
     256        case TITAN_CHIP_1056: 
     257        case TITAN_CHIP_1060: 
     258                return new_val; 
     259  
     260        default: 
     261                break; 
     262        } 
     263        /* In case we get an invalid value, return the default Titan chip */ 
     264        return TITAN_CHIP_1050; 
     265} 
     266 
    107267#include <asm-generic/gpio.h> 
    108268 
    109269#endif 
  • target/linux/ar7/files/include/asm-mips/ar7/titan.h

     
     1/* 
     2 * Copyright (C) 2008 Stanley Pinchak <stanley_dot_pinchak_at_gmail_dot_com> 
     3 * 
     4 * This program is free software; you can redistribute it and/or modify 
     5 * it under the terms of the GNU General Public License as published by 
     6 * the Free Software Foundation; either version 2 of the License, or 
     7 * (at your option) any later version. 
     8 * 
     9 * This program is distributed in the hope that it will be useful, 
     10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
     11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     12 * GNU General Public License for more details. 
     13 * 
     14 * You should have received a copy of the GNU General Public License 
     15 * along with this program; if not, write to the Free Software 
     16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA 
     17 */ 
     18#ifndef __AR7_TITAN_H__ 
     19#define __AR7_TITAN_H__ 
     20 
     21#ifndef __AR7_GPIO_H__ 
     22#include <asm/ar7/gpio.h> 
     23#endif 
     24 
     25typedef enum TITAN_GPIO_PIN_MODE_tag 
     26{ 
     27    FUNCTIONAL_PIN = 0, 
     28    GPIO_PIN = 1 
     29} TITAN_GPIO_PIN_MODE_T; 
     30 
     31typedef enum TITAN_GPIO_PIN_DIRECTION_tag 
     32{ 
     33    GPIO_OUTPUT_PIN = 0, 
     34    GPIO_INPUT_PIN = 1 
     35} TITAN_GPIO_PIN_DIRECTION_T; 
     36 
     37/********************************************************************** 
     38 *  GPIO Control 
     39 **********************************************************************/ 
     40 
     41typedef struct  
     42{ 
     43    int pinSelReg; 
     44    int shift; 
     45    int func; 
     46 
     47} GPIO_CFG; 
     48 
     49static GPIO_CFG gptable[]= { 
     50                      /* PIN_SEL_REG, START_BIT, GPIO_CFG_MUX_VALUE */ 
     51                      {4,24,1}, 
     52                      {4,26,1}, 
     53                      {4,28,1}, 
     54                      {4,30,1}, 
     55                      {5,6,1}, 
     56                      {5,8,1}, 
     57                      {5,10,1}, 
     58                      {5,12,1}, 
     59                      {7,14,3}, 
     60                      {7,16,3}, 
     61                      {7,18,3}, 
     62                      {7,20,3}, 
     63                      {7,22,3}, 
     64                      {7,26,3}, 
     65                      {7,28,3}, 
     66                      {7,30,3}, 
     67                      {8,0,3}, 
     68                      {8,2,3}, 
     69                      {8,4,3}, 
     70                      {8,10,3}, 
     71                      {8,14,3}, 
     72                      {8,16,3}, 
     73                      {8,18,3}, 
     74                      {8,20,3}, 
     75                      {9,8,3}, 
     76                      {9,10,3}, 
     77                      {9,12,3}, 
     78                      {9,14,3}, 
     79                      {9,18,3}, 
     80                      {9,20,3}, 
     81                      {9,24,3}, 
     82                      {9,26,3}, 
     83                      {9,28,3}, 
     84                      {9,30,3}, 
     85                      {10,0,3}, 
     86                      {10,2,3}, 
     87                      {10,8,3}, 
     88                      {10,10,3}, 
     89                      {10,12,3}, 
     90                      {10,14,3}, 
     91                      {13,12,3}, 
     92                      {13,14,3}, 
     93                      {13,16,3}, 
     94                      {13,18,3}, 
     95                      {13,24,3}, 
     96                      {13,26,3}, 
     97                      {13,28,3}, 
     98                      {13,30,3}, 
     99                      {14,2,3}, 
     100                      {14,6,3}, 
     101                      {14,8,3}, 
     102                      {14,12,3} 
     103}; 
     104 
     105typedef struct 
     106{ 
     107    volatile unsigned int reg[21]; 
     108} 
     109PIN_SEL_REG_ARRAY_T; 
     110 
     111typedef struct 
     112{ 
     113    unsigned int data_in [2]; 
     114    unsigned int data_out[2]; 
     115    unsigned int dir[2]; 
     116    unsigned int enable[2]; 
     117 
     118} TITAN_GPIO_CONTROL_T; 
     119 
     120#define AVALANCHE_PIN_SEL_BASE        0xA861160C /*replace with KSEG1ADDR()*/ 
     121 
     122static inline int titan_gpio_ctrl(unsigned int gpio_pin, TITAN_GPIO_PIN_MODE_T pin_mode, 
     123                        TITAN_GPIO_PIN_DIRECTION_T pin_direction) 
     124{ 
     125    int reg_index = 0; 
     126    int mux_status; 
     127    GPIO_CFG  gpio_cfg; 
     128    volatile PIN_SEL_REG_ARRAY_T *pin_sel_array = (PIN_SEL_REG_ARRAY_T*) AVALANCHE_PIN_SEL_BASE; 
     129    volatile TITAN_GPIO_CONTROL_T   *gpio_cntl     = (TITAN_GPIO_CONTROL_T*) KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_INPUT_0); 
     130         
     131    if (gpio_pin > 51 ) 
     132        return(-1); 
     133 
     134    gpio_cfg = gptable[gpio_pin]; 
     135    mux_status = (pin_sel_array->reg[gpio_cfg.pinSelReg - 1] >> gpio_cfg.shift) & 0x3; 
     136    if(!((mux_status == 0 /* tri-stated */ ) || (mux_status == gpio_cfg.func /*GPIO functionality*/))) 
     137    { 
     138        return(-1); /* Pin have been configured for non GPIO funcs. */ 
     139    } 
     140 
     141    /* Set the pin to be used as GPIO. */ 
     142    pin_sel_array->reg[gpio_cfg.pinSelReg - 1] |= ((gpio_cfg.func & 0x3) << gpio_cfg.shift); 
     143 
     144    /* Check whether gpio refers to the first GPIO reg or second. */ 
     145    if(gpio_pin > 31) 
     146    { 
     147        reg_index = 1; 
     148        gpio_pin -= 32; 
     149    } 
     150 
     151    if(pin_mode) 
     152        gpio_cntl->enable[reg_index] |=  (1 << gpio_pin); /* Enable */ 
     153    else 
     154        gpio_cntl->enable[reg_index] &= ~(1 << gpio_pin); 
     155 
     156    if(pin_direction) 
     157        gpio_cntl->dir[reg_index] |=  (1 << gpio_pin); /* Input */ 
     158    else 
     159        gpio_cntl->dir[reg_index] &= ~(1 << gpio_pin); 
     160 
     161    return(0); 
     162 
     163}/* end of function titan_gpio_ctrl */ 
     164 
     165static inline int titan_sysGpioInValue(unsigned int *in_val, unsigned int reg_index) 
     166{ 
     167    volatile TITAN_GPIO_CONTROL_T   *gpio_cntl     = (TITAN_GPIO_CONTROL_T*) KSEG1ADDR(AR7_REGS_GPIO + TITAN_GPIO_INPUT_0); 
     168 
     169    if(reg_index > 1) 
     170       return (-1); 
     171 
     172    *in_val = gpio_cntl->data_in[reg_index]; 
     173 
     174    return (0); 
     175} 
     176 
     177 
     178#endif 
     179 
  • target/linux/ar7/files/arch/mips/ar7/gpio.c

     
    2121 
    2222#include <asm/ar7/gpio.h> 
    2323 
    24 static const char *ar7_gpio_list[AR7_GPIO_MAX]; 
     24static const char *ar7_gpio_list[TITAN_GPIO_MAX]; 
    2525 
    2626int gpio_request(unsigned gpio, const char *label) 
    2727{ 
    28         if (gpio >= AR7_GPIO_MAX) 
     28        if (gpio >= (ar7_is_titan() ? TITAN_GPIO_MAX : AR7_GPIO_MAX)) 
    2929                return -EINVAL; 
    3030 
    3131        if (ar7_gpio_list[gpio]) 
  • target/linux/ar7/files/arch/mips/ar7/setup.c

     
    2323#include <asm/reboot.h> 
    2424#include <asm/time.h> 
    2525#include <asm/ar7/ar7.h> 
     26#include <asm/ar7/gpio.h> 
    2627#include <asm/ar7/prom.h> 
    2728 
     29static int titan_variant;  /*hold the results of the gpio_init_titan_variant() so that it is only called once*/ 
    2830#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24) /* TODO remove when 2.6.24 is stable */ 
    2931extern void ar7_time_init(void); 
    3032#endif 
     
    6264                return "TI AR7 (TNETD7100)"; 
    6365        case AR7_CHIP_7200: 
    6466                return "TI AR7 (TNETD7200)"; 
     67        case AR7_CHIP_TITAN: 
     68                titan_variant = ar7_init_titan_variant(); 
     69                switch (titan_variant /*(gpio_get_value_titan(1) >> 12) & 0xf*/) { 
     70                case TITAN_CHIP_1050: 
     71                        return "TI AR7 (TNETV1050)"; 
     72                case TITAN_CHIP_1055: 
     73                        return "TI AR7 (TNETV1055)"; 
     74                case TITAN_CHIP_1056: 
     75                        return "TI AR7 (TNETV1056)"; 
     76                case TITAN_CHIP_1060: 
     77                        return "TI AR7 (TNETV1060)"; 
     78                } 
    6579        default: 
    6680                return "TI AR7 (Unknown)"; 
    6781        } 
  • target/linux/ar7/files/arch/mips/ar7/platform.c

     
    126126        }, 
    127127}; 
    128128 
     129static struct resource cpmac_low_res_titan[] = { 
     130        { 
     131                .name = "regs", 
     132                .flags = IORESOURCE_MEM, 
     133                .start = TITAN_REGS_MAC0, 
     134                .end = TITAN_REGS_MAC0 + 0x7ff, 
     135        }, 
     136        { 
     137                .name = "irq", 
     138                .flags = IORESOURCE_IRQ, 
     139                .start = 27, 
     140                .end = 27, 
     141        }, 
     142}; 
     143 
     144static struct resource cpmac_high_res_titan[] = { 
     145        { 
     146                .name = "regs", 
     147                .flags = IORESOURCE_MEM, 
     148                .start = TITAN_REGS_MAC1, 
     149                .end = TITAN_REGS_MAC1 + 0x7ff, 
     150        }, 
     151        { 
     152                .name = "irq", 
     153                .flags = IORESOURCE_IRQ, 
     154                .start = 41, 
     155                .end = 41, 
     156        }, 
     157}; 
     158 
    129159static struct resource vlynq_low_res[] = { 
    130160        { 
    131161                .name = "regs", 
     
    180210        }, 
    181211}; 
    182212 
     213static struct resource vlynq_low_res_titan[] = { 
     214        { 
     215                .name = "regs", 
     216                .flags = IORESOURCE_MEM, 
     217                .start = TITAN_REGS_VLYNQ0, 
     218                .end = TITAN_REGS_VLYNQ0 + 0xff, 
     219        }, 
     220        { 
     221                .name = "irq", 
     222                .flags = IORESOURCE_IRQ, 
     223                .start = 33, 
     224                .end = 33, 
     225        }, 
     226        { 
     227                .name = "mem", 
     228                .flags = IORESOURCE_MEM, 
     229                .start = 0x0c000000, 
     230                .end = 0x0fffffff, 
     231        }, 
     232        { 
     233                .name = "devirq", 
     234                .flags = IORESOURCE_IRQ, 
     235                .start = 80, 
     236                .end = 111, 
     237        }, 
     238}; 
     239 
     240static struct resource vlynq_high_res_titan[] = { 
     241        { 
     242                .name = "regs", 
     243                .flags = IORESOURCE_MEM, 
     244                .start = TITAN_REGS_VLYNQ1, 
     245                .end = TITAN_REGS_VLYNQ1 + 0xff, 
     246        }, 
     247        { 
     248                .name = "irq", 
     249                .flags = IORESOURCE_IRQ, 
     250                .start = 34, 
     251                .end = 34, 
     252        }, 
     253        { 
     254                .name = "mem", 
     255                .flags = IORESOURCE_MEM, 
     256                .start = 0x40000000, 
     257                .end = 0x43ffffff, 
     258        }, 
     259        { 
     260                .name = "devirq", 
     261                .flags = IORESOURCE_IRQ, 
     262                .start = 112, 
     263                .end = 143, 
     264        }, 
     265}; 
     266 
    183267static struct resource usb_res[] = { 
    184268        { 
    185269                .name = "regs", 
     
    217301        .phy_mask = 0x7fffffff, 
    218302}; 
    219303 
     304static struct plat_cpmac_data cpmac_low_data_titan = { 
     305        .reset_bit = 17, 
     306        .power_bit = 20, 
     307        .phy_mask = 0x40000000, 
     308}; 
     309 
     310static struct plat_cpmac_data cpmac_high_data_titan = { 
     311        .reset_bit = 21, 
     312        .power_bit = 22, 
     313        .phy_mask = 0x80000000, 
     314}; 
     315 
    220316static struct plat_vlynq_data vlynq_low_data = { 
    221317        .ops.on = vlynq_on, 
    222318        .ops.off = vlynq_off, 
     
    231327        .gpio_bit = 19, 
    232328}; 
    233329 
     330static struct plat_vlynq_data vlynq_low_data_titan = { 
     331        .ops.on = vlynq_on, 
     332        .ops.off = vlynq_off, 
     333        .reset_bit = 15, 
     334        .gpio_bit = 14, 
     335}; 
     336 
     337static struct plat_vlynq_data vlynq_high_data_titan = { 
     338        .ops.on = vlynq_on, 
     339        .ops.off = vlynq_off, 
     340        .reset_bit = 16, 
     341        .gpio_bit = 7, 
     342}; 
     343 
    234344static struct platform_device physmap_flash = { 
    235345        .id = 0, 
    236346        .name = "physmap-flash", 
     
    264374        .num_resources = ARRAY_SIZE(cpmac_high_res), 
    265375}; 
    266376 
     377static struct platform_device cpmac_low_titan = { 
     378        .id = 0, 
     379        .name = "cpmac", 
     380        .dev = { 
     381                .dma_mask = &cpmac_dma_mask, 
     382                .coherent_dma_mask = DMA_32BIT_MASK, 
     383                .platform_data = &cpmac_low_data_titan, 
     384        }, 
     385        .resource = cpmac_low_res_titan, 
     386        .num_resources = ARRAY_SIZE(cpmac_low_res_titan), 
     387}; 
     388 
     389static struct platform_device cpmac_high_titan = { 
     390        .id = 1, 
     391        .name = "cpmac", 
     392        .dev = { 
     393                .dma_mask = &cpmac_dma_mask, 
     394                .coherent_dma_mask = DMA_32BIT_MASK, 
     395                .platform_data = &cpmac_high_data_titan, 
     396        }, 
     397        .resource = cpmac_high_res_titan, 
     398        .num_resources = ARRAY_SIZE(cpmac_high_res_titan), 
     399}; 
     400 
    267401static struct platform_device vlynq_low = { 
    268402        .id = 0, 
    269403        .name = "vlynq", 
     
    280414        .num_resources = ARRAY_SIZE(vlynq_high_res), 
    281415}; 
    282416 
     417static struct platform_device vlynq_low_titan = { 
     418        .id = 0, 
     419        .name = "vlynq", 
     420        .dev.platform_data = &vlynq_low_data_titan, 
     421        .resource = vlynq_low_res_titan, 
     422        .num_resources = ARRAY_SIZE(vlynq_low_res_titan), 
     423}; 
    283424 
     425static struct platform_device vlynq_high_titan = { 
     426        .id = 1, 
     427        .name = "vlynq", 
     428        .dev.platform_data = &vlynq_high_data_titan, 
     429        .resource = vlynq_high_res_titan, 
     430        .num_resources = ARRAY_SIZE(vlynq_high_res_titan), 
     431}; 
     432 
     433 
    284434/* This is proper way to define uart ports, but they are then detected 
    285435 * as xscale and, obviously, don't work... 
    286436 */ 
     
    324474        { .name = "status", .gpio = 8, .active_low = 1, }, 
    325475}; 
    326476 
     477static struct gpio_led titan_leds[] = { 
     478        { .name = "status", .gpio = 8, .active_low = 1, }, 
     479        { .name = "wifi", .gpio = 13, .active_low = 1, }, 
     480}; 
     481 
    327482static struct gpio_led dsl502t_leds[] = { 
    328483        { .name = "status", .gpio = 9, .active_low = 1, }, 
    329484        { .name = "ethernet", .gpio = 7, .active_low = 1, }, 
     
    416571        /* FIXME: the whole thing is unreliable */ 
    417572        prId = prom_getenv("ProductID"); 
    418573        usb_prod = prom_getenv("usb_prod"); 
    419          
     574 
    420575        /* If we can't get the product id from PROM, use the default LEDs */ 
    421576        if (!prId) 
    422577                return; 
     
    433588        } else if (strstr(prId, "DG834")) { 
    434589                ar7_led_data.num_leds = ARRAY_SIZE(dg834g_leds); 
    435590                ar7_led_data.leds = dg834g_leds; 
     591        } else if (strstr(prId, "CYWM")) { 
     592                ar7_led_data.num_leds = ARRAY_SIZE(titan_leds); 
     593                ar7_led_data.leds = titan_leds; 
    436594        } 
    437595} 
    438596 
     
    493651        if (res) 
    494652                return res; 
    495653 
    496         ar7_device_disable(vlynq_low_data.reset_bit); 
    497         res = platform_device_register(&vlynq_low); 
     654        ar7_device_disable(ar7_is_titan() ? vlynq_low_data_titan.reset_bit : 
     655                vlynq_low_data.reset_bit); 
     656        res = platform_device_register(ar7_is_titan() ? &vlynq_low_titan : 
     657                &vlynq_low); 
    498658        if (res) 
    499659                return res; 
    500660 
    501661        if (ar7_has_high_vlynq()) { 
    502                 ar7_device_disable(vlynq_high_data.reset_bit); 
    503                 res = platform_device_register(&vlynq_high); 
     662                ar7_device_disable(ar7_is_titan() ? vlynq_high_data_titan.reset_bit : 
     663                        vlynq_high_data.reset_bit); 
     664                res = platform_device_register(ar7_is_titan() ? &vlynq_high_titan : 
     665                        &vlynq_high); 
    504666                if (res) 
    505667                        return res; 
    506668        } 
    507669 
    508670        if (ar7_has_high_cpmac()) { 
    509                 cpmac_get_mac(1, cpmac_high_data.dev_addr); 
    510                 res = platform_device_register(&cpmac_high); 
     671                cpmac_get_mac(1, ar7_is_titan() ? cpmac_high_data_titan.dev_addr : 
     672                        cpmac_high_data.dev_addr); 
     673                res = platform_device_register(ar7_is_titan() ? &cpmac_high_titan : 
     674                        &cpmac_high); 
    511675                if (res) 
    512676                        return res; 
    513677        } else { 
    514                 cpmac_low_data.phy_mask = 0xffffffff; 
     678                if (ar7_is_titan()) 
     679                        cpmac_low_data_titan.phy_mask = 0xffffffff; 
     680                else 
     681                        cpmac_low_data.phy_mask = 0xffffffff; 
    515682        } 
    516683 
    517         cpmac_get_mac(0, cpmac_low_data.dev_addr); 
    518         res = platform_device_register(&cpmac_low); 
     684        cpmac_get_mac(0, ar7_is_titan() ? cpmac_low_data_titan.dev_addr : 
     685                cpmac_low_data.dev_addr); 
     686        res = platform_device_register(ar7_is_titan() ? &cpmac_low_titan : 
     687                &cpmac_low); 
    519688        if (res) 
    520689                return res; 
    521690 
  • target/linux/ar7/files/drivers/char/ar7_gpio.c

     
    9898{ 
    9999        int m = iminor(inode); 
    100100 
    101         if (m >= AR7_GPIO_MAX) 
     101        if (m >= (ar7_is_titan() ? TITAN_GPIO_MAX : AR7_GPIO_MAX)) 
    102102                return -EINVAL; 
    103103 
    104104        return nonseekable_open(inode, file);