Changeset 9741


Ignore:
Timestamp:
2007-12-13T23:28:15+01:00 (10 years ago)
Author:
blogic
Message:

danube gpio clean up

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/danube/files/drivers/char/danube_gpio.c

    r9740 r9741  
    3131 
    3232 
    33 #define DANUBE_PORT_OUT_REG                             0x00000010 
    34 #define DANUBE_PORT_IN_REG                              0x00000014 
    35 #define DANUBE_PORT_DIR_REG                             0x00000018 
    36 #define DANUBE_PORT_ALTSEL0_REG                 0x0000001C 
    37 #define DANUBE_PORT_ALTSEL1_REG                 0x00000020 
    38 #define DANUBE_PORT_OD_REG                              0x00000024 
    39 #define DANUBE_PORT_STOFF_REG                   0x00000028 
    40 #define DANUBE_PORT_PUDSEL_REG                  0x0000002C 
    41 #define DANUBE_PORT_PUDEN_REG                   0x00000030 
    42  
    43 #define PORT_MODULE_ID  0xff 
    44  
    45 #define PORT_WRITE_REG(reg, value)   \ 
    46                 *((volatile u32*)(reg)) = (u32)value; 
    47  
    48 #define PORT_READ_REG(reg, value)    \ 
    49                 value = (u32)*((volatile u32*)(reg)); 
    50  
    5133#define PORT_IOC_CALL(ret,port,pin,func)    \ 
    5234                ret=danube_port_reserve_pin(port,pin,PORT_MODULE_ID); \ 
     
    5537 
    5638 
    57 #define MAX_PORTS       2       // Number of ports in system 
    58 #define PINS_PER_PORT   16      // Number of available pins per port 
    59  
    60 static int port_major = 0; 
    61 static int danube_port_pin_usage[MAX_PORTS][PINS_PER_PORT];     // Map for pin usage 
    62 static u32 danube_port_bases[MAX_PORTS] 
    63         = { DANUBE_GPIO_BASE_ADDR, DANUBE_GPIO_P0_PUDEN }; 
    64  
     39#define MAX_PORTS                       2 
     40#define PINS_PER_PORT           16 
     41 
     42static unsigned int danube_gpio_major = 0; 
     43 
     44/* TODO do we need this ? */ 
    6545static struct semaphore port_sem; 
    6646 
    67 int 
    68 danube_port_reserve_pin (int port, int pin, int module_id) 
    69 { 
    70         if (port < 0 || pin < 0) 
    71                 return -EINVAL; 
    72         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    73                 return -EINVAL; 
    74  
    75         if (danube_port_pin_usage[port][pin] == 0) { 
    76                 danube_port_pin_usage[port][pin] = module_id; 
    77         } 
    78         else { 
    79                 return -EBUSY; 
    80         } 
    81  
    82         return 0; 
    83 } 
    84  
    85 int 
    86 danube_port_free_pin (int port, int pin, int module_id) 
    87 { 
    88  
    89         if (port < 0 || pin < 0) 
    90                 return -EINVAL; 
    91         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    92                 return -EINVAL; 
    93  
    94         if (danube_port_pin_usage[port][pin] != module_id) 
    95                 return -EBUSY; 
    96         danube_port_pin_usage[port][pin] = 0; 
    97  
    98         return 0; 
    99 } 
    100  
    101 int 
    102 danube_port_set_open_drain (int port, int pin, int module_id) 
    103 { 
    104         u32 reg; 
    105  
    106         if (port < 0 || pin < 0) 
    107                 return -EINVAL; 
    108         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    109                 return -EINVAL; 
    110  
    111         if (danube_port_pin_usage[port][pin] != module_id) 
    112                 return -EBUSY; 
    113  
    114         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_OD_REG, reg); 
    115         reg |= (1 << pin); 
    116         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_OD_REG, reg); 
    117  
    118         return 0; 
    119 } 
    120  
    121 int 
    122 danube_port_clear_open_drain (int port, int pin, int module_id) 
    123 { 
    124         u32 reg; 
    125  
    126         if (port < 0 || pin < 0) 
    127                 return -EINVAL; 
    128         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    129                 return -EINVAL; 
    130  
    131         if (danube_port_pin_usage[port][pin] != module_id) 
    132                 return -EBUSY; 
    133  
    134         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_OD_REG, reg); 
    135         reg &= ~(1 << pin); 
    136         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_OD_REG, reg); 
    137  
    138         return 0; 
    139 } 
    140  
    141 int 
    142 danube_port_set_pudsel (int port, int pin, int module_id) 
    143 { 
    144         u32 reg; 
    145  
    146         if (port < 0 || pin < 0) 
    147                 return -EINVAL; 
    148         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    149                 return -EINVAL; 
    150  
    151         if (danube_port_pin_usage[port][pin] != module_id) 
    152                 return -EBUSY; 
    153  
    154         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_PUDSEL_REG, reg); 
    155         reg |= (1 << pin); 
    156         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_PUDSEL_REG, 
    157                         reg); 
    158  
    159         return 0; 
    160 } 
    161  
    162 int 
    163 danube_port_clear_pudsel (int port, int pin, int module_id) 
    164 { 
    165         u32 reg; 
    166  
    167         if (port < 0 || pin < 0) 
    168                 return -EINVAL; 
    169         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    170                 return -EINVAL; 
    171  
    172         if (danube_port_pin_usage[port][pin] != module_id) 
    173                 return -EBUSY; 
    174  
    175         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_PUDSEL_REG, reg); 
    176         reg &= ~(1 << pin); 
    177         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_PUDSEL_REG, 
    178                         reg); 
    179  
    180         return 0; 
    181 } 
    182  
    183 int 
    184 danube_port_set_puden (int port, int pin, int module_id) 
    185 { 
    186         u32 reg; 
    187  
    188         if (port < 0 || pin < 0) 
    189                 return -EINVAL; 
    190         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    191                 return -EINVAL; 
    192  
    193         if (danube_port_pin_usage[port][pin] != module_id) 
    194                 return -EBUSY; 
    195  
    196         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_PUDEN_REG, reg); 
    197         reg |= (1 << pin); 
    198         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_PUDEN_REG, reg); 
    199  
    200         return 0; 
    201 } 
    202  
    203 int 
    204 danube_port_clear_puden (int port, int pin, int module_id) 
    205 { 
    206         u32 reg; 
    207  
    208         if (port < 0 || pin < 0) 
    209                 return -EINVAL; 
    210         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    211                 return -EINVAL; 
    212  
    213         if (danube_port_pin_usage[port][pin] != module_id) 
    214                 return -EBUSY; 
    215  
    216         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_PUDEN_REG, reg); 
    217         reg &= ~(1 << pin); 
    218         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_PUDEN_REG, reg); 
    219  
    220         return 0; 
    221 } 
    222  
    223 int 
    224 danube_port_set_stoff (int port, int pin, int module_id) 
    225 { 
    226         u32 reg; 
    227  
    228         if (port < 0 || pin < 0) 
    229                 return -EINVAL; 
    230         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    231                 return -EINVAL; 
    232  
    233         if (danube_port_pin_usage[port][pin] != module_id) 
    234                 return -EBUSY; 
    235  
    236         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_STOFF_REG, reg); 
    237         reg |= (1 << pin); 
    238         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_STOFF_REG, reg); 
    239  
    240         return 0; 
    241 } 
    242  
    243 int 
    244 danube_port_clear_stoff (int port, int pin, int module_id) 
    245 { 
    246         u32 reg; 
    247  
    248         if (port < 0 || pin < 0) 
    249                 return -EINVAL; 
    250         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    251                 return -EINVAL; 
    252  
    253         if (danube_port_pin_usage[port][pin] != module_id) 
    254                 return -EBUSY; 
    255  
    256         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_STOFF_REG, reg); 
    257         reg &= ~(1 << pin); 
    258         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_STOFF_REG, reg); 
    259  
    260         return 0; 
    261 } 
    262  
    263 int 
    264 danube_port_set_dir_out (int port, int pin, int module_id) 
    265 { 
    266         u32 reg; 
    267  
    268         if (port < 0 || pin < 0) 
    269                 return -EINVAL; 
    270         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    271                 return -EINVAL; 
    272  
    273         if (danube_port_pin_usage[port][pin] != module_id) 
    274                 return -EBUSY; 
    275  
    276         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_DIR_REG, reg); 
    277         reg |= (1 << pin); 
    278         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_DIR_REG, reg); 
    279  
    280         return 0; 
    281 } 
    282  
    283 int 
    284 danube_port_set_dir_in (int port, int pin, int module_id) 
    285 { 
    286         u32 reg; 
    287  
    288         if (port < 0 || pin < 0) 
    289                 return -EINVAL; 
    290         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    291                 return -EINVAL; 
    292  
    293         if (danube_port_pin_usage[port][pin] != module_id) 
    294                 return -EBUSY; 
    295  
    296         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_DIR_REG, reg); 
    297         reg &= ~(1 << pin); 
    298         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_DIR_REG, reg); 
    299  
    300         return 0; 
    301 } 
    302  
    303 int 
    304 danube_port_set_output (int port, int pin, int module_id) 
    305 { 
    306         u32 reg; 
    307  
    308         if (port < 0 || pin < 0) 
    309                 return -EINVAL; 
    310         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    311                 return -EINVAL; 
    312  
    313         if (danube_port_pin_usage[port][pin] != module_id) 
    314                 return -EBUSY; 
    315  
    316         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_OUT_REG, reg); 
    317         reg |= (1 << pin); 
    318         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_OUT_REG, reg); 
    319  
    320         return 0; 
    321 } 
    322  
    323 int 
    324 danube_port_clear_output (int port, int pin, int module_id) 
    325 { 
    326         u32 reg; 
    327  
    328         if (port < 0 || pin < 0) 
    329                 return -EINVAL; 
    330         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    331                 return -EINVAL; 
    332  
    333         if (danube_port_pin_usage[port][pin] != module_id) 
    334                 return -EBUSY; 
    335  
    336         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_OUT_REG, reg); 
    337         reg &= ~(1 << pin); 
    338         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_OUT_REG, reg); 
    339  
    340         return 0; 
    341 } 
    342  
    343 int 
    344 danube_port_get_input (int port, int pin, int module_id) 
    345 { 
    346         u32 reg; 
    347  
    348         if (port < 0 || pin < 0) 
    349                 return -EINVAL; 
    350         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    351                 return -EINVAL; 
    352  
    353         if (danube_port_pin_usage[port][pin] != module_id) 
    354                 return -EBUSY; 
    355  
    356         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_IN_REG, reg); 
    357         reg &= (1 << pin); 
    358         if (reg == 0x00) 
     47/* TODO do we really need this ? return in a define is forbidden by coding style */ 
     48#define DANUBE_GPIO_SANITY              {if (port > MAX_PORTS || pin > PINS_PER_PORT) return -EINVAL; } 
     49 
     50int 
     51danube_port_reserve_pin (unsigned int port, unsigned int pin) 
     52{ 
     53        DANUBE_GPIO_SANITY; 
     54        printk("%s : call to obseleted function\n", __func__); 
     55 
     56        return 0; 
     57} 
     58EXPORT_SYMBOL(danube_port_reserve_pin); 
     59 
     60int 
     61danube_port_free_pin (unsigned int port, unsigned int pin) 
     62{ 
     63        DANUBE_GPIO_SANITY; 
     64        printk("%s : call to obseleted function\n", __func__); 
     65 
     66        return 0; 
     67} 
     68EXPORT_SYMBOL(danube_port_free_pin); 
     69 
     70int 
     71danube_port_set_open_drain (unsigned int port, unsigned int pin) 
     72{ 
     73        DANUBE_GPIO_SANITY; 
     74        writel(readl(DANUBE_GPIO_P0_OD + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_OD); 
     75 
     76        return 0; 
     77} 
     78EXPORT_SYMBOL(danube_port_set_open_drain); 
     79 
     80int 
     81danube_port_clear_open_drain (unsigned int port, unsigned int pin) 
     82{ 
     83        DANUBE_GPIO_SANITY; 
     84        writel(readl(DANUBE_GPIO_P0_OD + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_OD); 
     85 
     86        return 0; 
     87} 
     88EXPORT_SYMBOL(danube_port_clear_open_drain); 
     89 
     90int 
     91danube_port_set_pudsel (unsigned int port, unsigned int pin) 
     92{ 
     93    DANUBE_GPIO_SANITY; 
     94        writel(readl(DANUBE_GPIO_P0_PUDSEL + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_PUDSEL); 
     95 
     96        return 0; 
     97} 
     98EXPORT_SYMBOL(danube_port_set_pudsel); 
     99 
     100int 
     101danube_port_clear_pudsel (unsigned int port, unsigned int pin) 
     102{ 
     103    DANUBE_GPIO_SANITY; 
     104        writel(readl(DANUBE_GPIO_P0_PUDSEL + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_PUDSEL); 
     105 
     106        return 0; 
     107} 
     108EXPORT_SYMBOL(danube_port_clear_pudsel); 
     109 
     110int 
     111danube_port_set_puden (unsigned int port, unsigned int pin) 
     112{ 
     113    DANUBE_GPIO_SANITY; 
     114        writel(readl(DANUBE_GPIO_P0_PUDEN + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_PUDEN); 
     115 
     116        return 0; 
     117} 
     118EXPORT_SYMBOL(danube_port_set_puden); 
     119 
     120int 
     121danube_port_clear_puden (unsigned int port, unsigned int pin) 
     122{ 
     123    DANUBE_GPIO_SANITY; 
     124        writel(readl(DANUBE_GPIO_P0_PUDEN + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_PUDEN); 
     125 
     126        return 0; 
     127} 
     128EXPORT_SYMBOL(danube_port_clear_puden); 
     129 
     130int 
     131danube_port_set_stoff (unsigned int port, unsigned int pin) 
     132{ 
     133    DANUBE_GPIO_SANITY; 
     134        writel(readl(DANUBE_GPIO_P0_STOFF + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_STOFF); 
     135 
     136        return 0; 
     137} 
     138EXPORT_SYMBOL(danube_port_set_stoff); 
     139 
     140int 
     141danube_port_clear_stoff (unsigned int port, unsigned int pin) 
     142{ 
     143    DANUBE_GPIO_SANITY; 
     144        writel(readl(DANUBE_GPIO_P0_STOFF + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_STOFF); 
     145 
     146        return 0; 
     147} 
     148EXPORT_SYMBOL(danube_port_clear_stoff); 
     149 
     150int 
     151danube_port_set_dir_out (unsigned int port, unsigned int pin) 
     152{ 
     153    DANUBE_GPIO_SANITY; 
     154        writel(readl(DANUBE_GPIO_P0_DIR + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_DIR); 
     155 
     156        return 0; 
     157} 
     158EXPORT_SYMBOL(danube_port_set_dir_out); 
     159 
     160int 
     161danube_port_set_dir_in (unsigned int port, unsigned int pin) 
     162{ 
     163    DANUBE_GPIO_SANITY; 
     164        writel(readl(DANUBE_GPIO_P0_DIR + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_DIR); 
     165 
     166        return 0; 
     167} 
     168EXPORT_SYMBOL(danube_port_set_dir_in); 
     169 
     170int 
     171danube_port_set_output (unsigned int port, unsigned int pin) 
     172{ 
     173    DANUBE_GPIO_SANITY; 
     174        writel(readl(DANUBE_GPIO_P0_OUT + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_OUT); 
     175 
     176        return 0; 
     177} 
     178EXPORT_SYMBOL(danube_port_set_output); 
     179 
     180int 
     181danube_port_clear_output (unsigned int port, unsigned int pin) 
     182{ 
     183    DANUBE_GPIO_SANITY; 
     184        writel(readl(DANUBE_GPIO_P0_OUT + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_OUT); 
     185 
     186        return 0; 
     187} 
     188EXPORT_SYMBOL(danube_port_clear_output); 
     189 
     190int 
     191danube_port_get_input (unsigned int port, unsigned int pin) 
     192{ 
     193    DANUBE_GPIO_SANITY; 
     194 
     195        if (readl(DANUBE_GPIO_P0_IN + (port * 0x30)) & (1 << pin)) 
    359196                return 0; 
    360197        else 
    361198                return 1; 
    362199} 
    363  
    364 int 
    365 danube_port_set_altsel0 (int port, int pin, int module_id) 
    366 { 
    367         u32 reg; 
    368  
    369         if (port < 0 || pin < 0) 
    370                 return -EINVAL; 
    371         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    372                 return -EINVAL; 
    373  
    374         if (danube_port_pin_usage[port][pin] != module_id) 
    375                 return -EBUSY; 
    376  
    377         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL0_REG, 
    378                        reg); 
    379         reg |= (1 << pin); 
    380         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL0_REG, 
    381                         reg); 
    382  
    383         return 0; 
    384 } 
    385  
    386 int 
    387 danube_port_clear_altsel0 (int port, int pin, int module_id) 
    388 { 
    389         u32 reg; 
    390  
    391         if (port < 0 || pin < 0) 
    392                 return -EINVAL; 
    393         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    394                 return -EINVAL; 
    395  
    396         if (danube_port_pin_usage[port][pin] != module_id) 
    397                 return -EBUSY; 
    398  
    399         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL0_REG, 
    400                        reg); 
    401         reg &= ~(1 << pin); 
    402         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL0_REG, 
    403                         reg); 
    404  
    405         return 0; 
    406 } 
    407  
    408 int 
    409 danube_port_set_altsel1 (int port, int pin, int module_id) 
    410 { 
    411         u32 reg; 
    412  
    413         if (port < 0 || pin < 0) 
    414                 return -EINVAL; 
    415         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    416                 return -EINVAL; 
    417  
    418         if (danube_port_pin_usage[port][pin] != module_id) 
    419                 return -EBUSY; 
    420  
    421         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL1_REG, 
    422                        reg); 
    423         reg |= (1 << pin); 
    424         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL1_REG, 
    425                         reg); 
    426  
    427         return 0; 
    428 } 
    429  
    430 int 
    431 danube_port_clear_altsel1 (int port, int pin, int module_id) 
    432 { 
    433         u32 reg; 
    434  
    435         if (port < 0 || pin < 0) 
    436                 return -EINVAL; 
    437         if (port > MAX_PORTS || pin > PINS_PER_PORT) 
    438                 return -EINVAL; 
    439  
    440         if (danube_port_pin_usage[port][pin] != module_id) 
    441                 return -EBUSY; 
    442  
    443         PORT_READ_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL1_REG, 
    444                        reg); 
    445         reg &= ~(1 << pin); 
    446         PORT_WRITE_REG (danube_port_bases[port] + DANUBE_PORT_ALTSEL1_REG, 
    447                         reg); 
    448  
    449         return 0; 
    450 } 
    451  
    452 int 
    453 danube_port_read_procmem (char *buf, char **start, off_t offset, int count, 
    454                           int *eof, void *data) 
    455 { 
    456         long len = 0; 
    457         int t = 0; 
    458         u32 bit = 0; 
    459         u32 reg = 0; 
    460  
    461         len = sprintf (buf, "\nDanube Port Settings\n"); 
    462  
    463         len = len + sprintf (buf + len, 
    464                              "         3         2         1         0\n"); 
    465         len = len + sprintf (buf + len, 
    466                              "        10987654321098765432109876543210\n"); 
    467         len = len + sprintf (buf + len, 
    468                              "----------------------------------------\n"); 
    469  
    470         len = len + sprintf (buf + len, "\nP0-OUT: "); 
    471         PORT_READ_REG (DANUBE_GPIO_P0_OUT, reg); 
     200EXPORT_SYMBOL(danube_port_get_input); 
     201 
     202int 
     203danube_port_set_altsel0 (unsigned int port, unsigned int pin) 
     204{ 
     205    DANUBE_GPIO_SANITY; 
     206        writel(readl(DANUBE_GPIO_P0_ALTSEL0 + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_ALTSEL0); 
     207 
     208        return 0; 
     209} 
     210EXPORT_SYMBOL(danube_port_set_altsel0); 
     211 
     212int 
     213danube_port_clear_altsel0 (unsigned int port, unsigned int pin) 
     214{ 
     215    DANUBE_GPIO_SANITY; 
     216        writel(readl(DANUBE_GPIO_P0_ALTSEL0 + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_ALTSEL0); 
     217 
     218        return 0; 
     219} 
     220EXPORT_SYMBOL(danube_port_clear_altsel0); 
     221 
     222int 
     223danube_port_set_altsel1 (unsigned int port, unsigned int pin) 
     224{ 
     225    DANUBE_GPIO_SANITY; 
     226        writel(readl(DANUBE_GPIO_P0_ALTSEL1 + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_ALTSEL1); 
     227 
     228        return 0; 
     229} 
     230EXPORT_SYMBOL(danube_port_set_altsel1); 
     231 
     232int 
     233danube_port_clear_altsel1 (unsigned int port, unsigned int pin) 
     234{ 
     235    DANUBE_GPIO_SANITY; 
     236        writel(readl(DANUBE_GPIO_P0_ALTSEL1 + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_ALTSEL1); 
     237 
     238        return 0; 
     239} 
     240EXPORT_SYMBOL(danube_port_clear_altsel1); 
     241 
     242long danube_port_read_procmem_helper(char* tag, u32* in_reg, char *buf) 
     243{ 
     244        u32 reg, bit = 0; 
     245        unsigned int len, t; 
     246 
     247        len = sprintf(buf, "\n%s: ", tag); 
     248        reg = readl(in_reg); 
    472249        bit = 0x80000000; 
    473250        for (t = 0; t < 32; t++) { 
    474251                if ((reg & bit) > 0) 
    475                         len = len + sprintf (buf + len, "X"); 
     252                        len = len + sprintf(buf + len, "X"); 
    476253                else 
    477                         len = len + sprintf (buf + len, " "); 
     254                        len = len + sprintf(buf + len, " "); 
    478255                bit = bit >> 1; 
    479256        } 
    480257 
    481         len = len + sprintf (buf + len, "\nP1-OUT: "); 
    482         PORT_READ_REG (DANUBE_GPIO_P1_OUT, reg); 
    483         bit = 0x80000000; 
    484         for (t = 0; t < 32; t++) { 
    485                 if ((reg & bit) > 0) 
    486                         len = len + sprintf (buf + len, "X"); 
    487                 else 
    488                         len = len + sprintf (buf + len, " "); 
    489                 bit = bit >> 1; 
    490         } 
    491  
    492         len = len + sprintf (buf + len, "\nP0-IN:  "); 
    493         PORT_READ_REG (DANUBE_GPIO_P0_IN, reg); 
    494         bit = 0x80000000; 
    495         for (t = 0; t < 32; t++) { 
    496                 if ((reg & bit) > 0) 
    497                         len = len + sprintf (buf + len, "X"); 
    498                 else 
    499                         len = len + sprintf (buf + len, " "); 
    500                 bit = bit >> 1; 
    501         } 
    502  
    503         len = len + sprintf (buf + len, "\nP1-IN:  "); 
    504         PORT_READ_REG (DANUBE_GPIO_P1_IN, reg); 
    505         bit = 0x80000000; 
    506         for (t = 0; t < 32; t++) { 
    507                 if ((reg & bit) > 0) 
    508                         len = len + sprintf (buf + len, "X"); 
    509                 else 
    510                         len = len + sprintf (buf + len, " "); 
    511                 bit = bit >> 1; 
    512         } 
    513  
    514         len = len + sprintf (buf + len, "\nP0-DIR: "); 
    515         PORT_READ_REG (DANUBE_GPIO_P0_DIR, reg); 
    516         bit = 0x80000000; 
    517         for (t = 0; t < 32; t++) { 
    518                 if ((reg & bit) > 0) 
    519                         len = len + sprintf (buf + len, "X"); 
    520                 else 
    521                         len = len + sprintf (buf + len, " "); 
    522                 bit = bit >> 1; 
    523         } 
    524  
    525         len = len + sprintf (buf + len, "\nP1-DIR: "); 
    526         PORT_READ_REG (DANUBE_GPIO_P1_DIR, reg); 
    527         bit = 0x80000000; 
    528         for (t = 0; t < 32; t++) { 
    529                 if ((reg & bit) > 0) 
    530                         len = len + sprintf (buf + len, "X"); 
    531                 else 
    532                         len = len + sprintf (buf + len, " "); 
    533                 bit = bit >> 1; 
    534         } 
    535  
    536         len = len + sprintf (buf + len, "\nP0-STO: "); 
    537         PORT_READ_REG (DANUBE_GPIO_P0_STOFF, reg); 
    538         bit = 0x80000000; 
    539         for (t = 0; t < 32; t++) { 
    540                 if ((reg & bit) > 0) 
    541                         len = len + sprintf (buf + len, "X"); 
    542                 else 
    543                         len = len + sprintf (buf + len, " "); 
    544                 bit = bit >> 1; 
    545         } 
    546  
    547         len = len + sprintf (buf + len, "\nP1-STO: "); 
    548         PORT_READ_REG (DANUBE_GPIO_P1_STOFF, reg); 
    549         bit = 0x80000000; 
    550         for (t = 0; t < 32; t++) { 
    551                 if ((reg & bit) > 0) 
    552                         len = len + sprintf (buf + len, "X"); 
    553                 else 
    554                         len = len + sprintf (buf + len, " "); 
    555                 bit = bit >> 1; 
    556         } 
    557  
    558         len = len + sprintf (buf + len, "\nP0-PUDE:"); 
    559         PORT_READ_REG (DANUBE_GPIO_P0_PUDEN, reg); 
    560         bit = 0x80000000; 
    561         for (t = 0; t < 32; t++) { 
    562                 if ((reg & bit) > 0) 
    563                         len = len + sprintf (buf + len, "X"); 
    564                 else 
    565                         len = len + sprintf (buf + len, " "); 
    566                 bit = bit >> 1; 
    567         } 
    568  
    569         len = len + sprintf (buf + len, "\nP1-PUDE:"); 
    570         PORT_READ_REG (DANUBE_GPIO_P1_PUDEN, reg); 
    571         bit = 0x80000000; 
    572         for (t = 0; t < 32; t++) { 
    573                 if ((reg & bit) > 0) 
    574                         len = len + sprintf (buf + len, "X"); 
    575                 else 
    576                         len = len + sprintf (buf + len, " "); 
    577                 bit = bit >> 1; 
    578         } 
    579  
    580         len = len + sprintf (buf + len, "\nP0-OD:  "); 
    581         PORT_READ_REG (DANUBE_GPIO_P0_OD, reg); 
    582         bit = 0x80000000; 
    583         for (t = 0; t < 32; t++) { 
    584                 if ((reg & bit) > 0) 
    585                         len = len + sprintf (buf + len, "X"); 
    586                 else 
    587                         len = len + sprintf (buf + len, " "); 
    588                 bit = bit >> 1; 
    589         } 
    590  
    591         len = len + sprintf (buf + len, "\nP1-OD:  "); 
    592         PORT_READ_REG (DANUBE_GPIO_P1_OD, reg); 
    593         bit = 0x80000000; 
    594         for (t = 0; t < 32; t++) { 
    595                 if ((reg & bit) > 0) 
    596                         len = len + sprintf (buf + len, "X"); 
    597                 else 
    598                         len = len + sprintf (buf + len, " "); 
    599                 bit = bit >> 1; 
    600         } 
    601  
    602         len = len + sprintf (buf + len, "\nP0-PUDS:"); 
    603         PORT_READ_REG (DANUBE_GPIO_P0_PUDSEL, reg); 
    604         bit = 0x80000000; 
    605         for (t = 0; t < 32; t++) { 
    606                 if ((reg & bit) > 0) 
    607                         len = len + sprintf (buf + len, "X"); 
    608                 else 
    609                         len = len + sprintf (buf + len, " "); 
    610                 bit = bit >> 1; 
    611         } 
    612  
    613         len = len + sprintf (buf + len, "\nP1-PUDS:"); 
    614         PORT_READ_REG (DANUBE_GPIO_P1_PUDSEL, reg); 
    615         bit = 0x80000000; 
    616         for (t = 0; t < 32; t++) { 
    617                 if ((reg & bit) > 0) 
    618                         len = len + sprintf (buf + len, "X"); 
    619                 else 
    620                         len = len + sprintf (buf + len, " "); 
    621                 bit = bit >> 1; 
    622         } 
    623  
    624         len = len + sprintf (buf + len, "\nP0_ALT0:"); 
    625         PORT_READ_REG (DANUBE_GPIO_P0_ALTSEL0, reg); 
    626         bit = 0x80000000; 
    627         for (t = 0; t < 32; t++) { 
    628                 if ((reg & bit) > 0) 
    629                         len = len + sprintf (buf + len, "X"); 
    630                 else 
    631                         len = len + sprintf (buf + len, " "); 
    632                 bit = bit >> 1; 
    633         } 
    634  
    635         len = len + sprintf (buf + len, "\nP0_ALT1:"); 
    636         PORT_READ_REG (DANUBE_GPIO_P0_ALTSEL1, reg); 
    637         bit = 0x80000000; 
    638         for (t = 0; t < 32; t++) { 
    639                 if ((reg & bit) > 0) 
    640                         len = len + sprintf (buf + len, "X"); 
    641                 else 
    642                         len = len + sprintf (buf + len, " "); 
    643                 bit = bit >> 1; 
    644         } 
    645  
    646         len = len + sprintf (buf + len, "\nP1_ALT0:"); 
    647         PORT_READ_REG (DANUBE_GPIO_P1_ALTSEL0, reg); 
    648         bit = 0x80000000; 
    649         for (t = 0; t < 32; t++) { 
    650                 if ((reg & bit) > 0) 
    651                         len = len + sprintf (buf + len, "X"); 
    652                 else 
    653                         len = len + sprintf (buf + len, " "); 
    654                 bit = bit >> 1; 
    655         } 
    656  
    657         len = len + sprintf (buf + len, "\nP1_ALT1:"); 
    658         PORT_READ_REG (DANUBE_GPIO_P1_ALTSEL1, reg); 
    659         bit = 0x80000000; 
    660         for (t = 0; t < 32; t++) { 
    661                 if ((reg & bit) > 0) 
    662                         len = len + sprintf (buf + len, "X"); 
    663                 else 
    664                         len = len + sprintf (buf + len, " "); 
    665                 bit = bit >> 1; 
    666         } 
    667  
     258        return len; 
     259} 
     260 
     261int 
     262danube_port_read_procmem (char *buf, char **start, off_t offset, int count, 
     263                          int *eof, void *data) 
     264{ 
     265        long len = sprintf (buf, "\nDanube Port Settings\n"); 
     266 
     267        len += sprintf (buf + len, 
     268                        "         3         2         1         0\n"); 
     269        len += sprintf (buf + len, 
     270                        "        10987654321098765432109876543210\n"); 
     271        len += sprintf (buf + len, 
     272                        "----------------------------------------\n"); 
     273 
     274        len += danube_port_read_procmem_helper("P0-OUT", DANUBE_GPIO_P0_OUT, &buf[len]); 
     275        len += danube_port_read_procmem_helper("P1-OUT", DANUBE_GPIO_P1_OUT, &buf[len]); 
     276        len += danube_port_read_procmem_helper("P0-IN ", DANUBE_GPIO_P0_IN, &buf[len]); 
     277        len += danube_port_read_procmem_helper("P1-IN ", DANUBE_GPIO_P1_IN, &buf[len]); 
     278        len += danube_port_read_procmem_helper("P0-DIR", DANUBE_GPIO_P0_DIR, &buf[len]); 
     279        len += danube_port_read_procmem_helper("P1-DIR", DANUBE_GPIO_P1_DIR, &buf[len]); 
     280        len += danube_port_read_procmem_helper("P0-STO ", DANUBE_GPIO_P0_STOFF, &buf[len]); 
     281        len += danube_port_read_procmem_helper("P1-STO ", DANUBE_GPIO_P1_STOFF, &buf[len]); 
     282        len += danube_port_read_procmem_helper("P0-PUDE", DANUBE_GPIO_P0_PUDEN, &buf[len]); 
     283        len += danube_port_read_procmem_helper("P1-PUDE", DANUBE_GPIO_P1_PUDEN, &buf[len]); 
     284        len += danube_port_read_procmem_helper("P0-OD  ", DANUBE_GPIO_P0_OD, &buf[len]); 
     285        len += danube_port_read_procmem_helper("P1-OD  ", DANUBE_GPIO_P1_OD, &buf[len]); 
     286        len += danube_port_read_procmem_helper("P0-PUDS", DANUBE_GPIO_P0_PUDSEL, &buf[len]); 
     287        len += danube_port_read_procmem_helper("P1-PUDS", DANUBE_GPIO_P1_PUDSEL, &buf[len]); 
     288        len += danube_port_read_procmem_helper("P0-ALT0", DANUBE_GPIO_P0_ALTSEL0, &buf[len]); 
     289        len += danube_port_read_procmem_helper("P1-ALT0", DANUBE_GPIO_P1_ALTSEL0, &buf[len]); 
     290        len += danube_port_read_procmem_helper("P0-ALT1", DANUBE_GPIO_P0_ALTSEL1, &buf[len]); 
     291        len += danube_port_read_procmem_helper("P1-ALT1", DANUBE_GPIO_P1_ALTSEL1, &buf[len]); 
    668292        len = len + sprintf (buf + len, "\n\n"); 
    669293 
    670         *eof = 1;               // No more data available 
     294        *eof = 1; 
     295 
    671296        return len; 
    672297} 
     
    815440 
    816441static struct file_operations port_fops = { 
    817       open:danube_port_open, 
    818       release:danube_port_release, 
    819       ioctl:danube_port_ioctl 
     442      .open = danube_port_open, 
     443      .release = danube_port_release, 
     444      .ioctl = danube_port_ioctl 
    820445}; 
    821446 
    822447int __init 
    823 danube_port_init (void) 
    824 { 
    825         int t = 0; 
    826         int i = 0; 
    827         int err = 0; 
    828         printk ("Danube Port Initialization\n"); 
     448danube_gpio_init (void) 
     449{ 
     450        int retval = 0; 
    829451 
    830452        sema_init (&port_sem, 1); 
    831453 
    832         /* Check ports for available pins */ 
    833         for (t = 0; t < MAX_PORTS; t++) { 
    834                 for (i = 0; i < PINS_PER_PORT; i++) 
    835                         danube_port_pin_usage[t][i] = 0; 
     454        danube_gpio_major = register_chrdev(0, "danube_gpio", &port_fops); 
     455        if (!danube_gpio_major) 
     456        { 
     457                printk("danube-port: Error! Could not register port device. #%d\n", danube_gpio_major); 
     458                retval = -EINVAL; 
     459                goto out; 
    836460        } 
    837461 
    838         /* register port device */ 
    839         err = register_chrdev (0, "danube-port", &port_fops); 
    840         if (err > 0) 
    841                 port_major = err; 
    842         else { 
    843                 printk ("danube-port: Error! Could not register port device. #%d\n", err); 
    844                 return err; 
    845         } 
    846  
    847         /* Create proc file */ 
    848         create_proc_read_entry ("driver/danube_port", 0, NULL, 
     462        create_proc_read_entry("driver/danube_port", 0, NULL, 
    849463                                danube_port_read_procmem, NULL); 
    850464 
    851         return 0; 
    852 } 
    853  
    854 module_init (danube_port_init); 
    855  
    856 EXPORT_SYMBOL (danube_port_reserve_pin); 
    857 EXPORT_SYMBOL (danube_port_free_pin); 
    858 EXPORT_SYMBOL (danube_port_set_open_drain); 
    859 EXPORT_SYMBOL (danube_port_clear_open_drain); 
    860 EXPORT_SYMBOL (danube_port_set_pudsel); 
    861 EXPORT_SYMBOL (danube_port_clear_pudsel); 
    862 EXPORT_SYMBOL (danube_port_set_puden); 
    863 EXPORT_SYMBOL (danube_port_clear_puden); 
    864 EXPORT_SYMBOL (danube_port_set_stoff); 
    865 EXPORT_SYMBOL (danube_port_clear_stoff); 
    866 EXPORT_SYMBOL (danube_port_set_dir_out); 
    867 EXPORT_SYMBOL (danube_port_set_dir_in); 
    868 EXPORT_SYMBOL (danube_port_set_output); 
    869 EXPORT_SYMBOL (danube_port_clear_output); 
    870 EXPORT_SYMBOL (danube_port_get_input); 
    871  
    872 EXPORT_SYMBOL (danube_port_set_altsel0); 
    873 EXPORT_SYMBOL (danube_port_clear_altsel0); 
    874 EXPORT_SYMBOL (danube_port_set_altsel1); 
    875 EXPORT_SYMBOL (danube_port_clear_altsel1); 
     465        printk("registered danube gpio driver\n"); 
     466 
     467out: 
     468        return retval; 
     469} 
     470 
     471void __exit 
     472danube_gpio_exit (void) 
     473{ 
     474        unregister_chrdev(danube_gpio_major, "danube_gpio"); 
     475        remove_proc_entry("danube_wdt", NULL); 
     476} 
     477 
     478module_init(danube_gpio_init); 
     479module_exit(danube_gpio_exit); 
Note: See TracChangeset for help on using the changeset viewer.