Changeset 506a805 in mainline


Ignore:
Timestamp:
2011-01-06T14:57:42Z (13 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
2a6e4ac2
Parents:
d3c9b60
Message:

cstyle

Location:
uspace/srv/hw/netif/dp8390
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/hw/netif/dp8390/dp8390.c

    rd3c9b60 r506a805  
    338338        (*dep->de_initf)(dep);
    339339       
    340         if (debug) {
    341                 printf("%s: Ethernet address ", dep->de_name);
    342                 for (i = 0; i < 6; i++)
    343                         printf("%x%c", dep->de_address.ea_addr[i], i < 5 ? ':' : '\n');
    344         }
     340        printf("%s: Ethernet address ", dep->de_name);
     341        for (i = 0; i < 6; i++)
     342                printf("%x%c", dep->de_address.ea_addr[i], i < 5 ? ':' : '\n');
    345343       
    346344        /*
    … …  
    516514                        if (isr &ISR_TXE)
    517515                        {
    518 #if DEBUG
    519  {printf("%s: got send Error\n", dep->de_name);}
    520 #endif
    521516                                dep->de_stat.ets_sendErr++;
    522517                        }
    … …  
    558553                        {
    559554                                /* Software bug? */
    560                                 assert(!debug);
     555                                assert(false);
    561556
    562557                                /* Or hardware bug? */

  • uspace/srv/hw/netif/dp8390/dp8390.h

    rd3c9b60 r506a805  
    351351#define DEM_ENABLED     0x2
    352352
    353 #define debug           1
    354 
    355353#endif
    356354

  • uspace/srv/hw/netif/dp8390/ne2000.c

    rd3c9b60 r506a805  
    1616#include "ne2000.h"
    1717
    18 /** Number of bytes to transfer.
    19  */
    20 #define N 100
    21 
    22 /** Sleeps for the defined millicesonds.
    23  *  @param[in] millis The number of milliseconds to sleep.
    24  */
    25 #define milli_delay(millis)     usleep((millis) * 1000)
     18/** Number of bytes to transfer */
     19#define N  100
    2620
    2721/** Type definition of the testing function.
    … …  
    2923_PROTOTYPE(typedef int (*testf_t), (dpeth_t *dep, int pos, u8_t *pat)   );
    3024
    31 /** First data pattern.
    32  */
    33 u8_t    pat0[]= {0x00, 0x00, 0x00, 0x00};
    34 
    35 /** Second data pattern.
    36  */
    37 u8_t    pat1[]= {0xFF, 0xFF, 0xFF, 0xFF};
    38 
    39 /** Third data pattern.
    40  */
    41 u8_t    pat2[]= {0xA5, 0x5A, 0x69, 0x96};
    42 
    43 /** Fourth data pattern.
    44  */
    45 u8_t    pat3[]= {0x96, 0x69, 0x5A, 0xA5};
     25/** Data patterns */
     26u8_t pat0[]= {0x00, 0x00, 0x00, 0x00};
     27u8_t pat1[]= {0xFF, 0xFF, 0xFF, 0xFF};
     28u8_t pat2[]= {0xA5, 0x5A, 0x69, 0x96};
     29u8_t pat3[]= {0x96, 0x69, 0x5A, 0xA5};
    4630
    4731/** Tests 8 bit NE2000 network interface.
    … …  
    9276                /* Reset the ethernet card */
    9377                byte= inb_ne(dep, NE_RESET);
    94                 milli_delay(2);
     78                usleep(2000);
    9579                outb_ne(dep, NE_RESET, byte);
    96                 milli_delay(2);
     80                usleep(2000);
    9781               
    9882                /* Reset the dp8390 */
    … …  
    193177        dep->de_irq &= ~DEI_DEFAULT;
    194178       
    195         if (!debug)
    196         {
    197                 printf("%s: NE%d000 at %#lx:%d\n",
    198                     dep->de_name, dep->de_16bit ? 2 : 1,
    199                     dep->de_base_port, dep->de_irq);
    200         }
    201         else
    202         {
    203                 printf("%s: Novell NE%d000 ethernet card at I/O address "
    204                     "%#lx, memory size %#lx, irq %d\n",
    205                     dep->de_name, dep->de_16bit ? 2 : 1,
    206                     dep->de_base_port, dep->de_ramsize, dep->de_irq);
    207         }
    208 }
    209 
    210 /*===========================================================================*
    211  *                              test_8                                       *
    212  *===========================================================================*/
    213 static int test_8(dep, pos, pat)
    214 dpeth_t *dep;
    215 int pos;
    216 u8_t *pat;
     179        printf("%s: Novell NE%d000 ethernet card at I/O address "
     180            "%#lx, memory size %#lx, irq %d\n",
     181            dep->de_name, dep->de_16bit ? 2 : 1,
     182            dep->de_base_port, dep->de_ramsize, dep->de_irq);
     183}
     184
     185static int test_8(dpeth_t *dep, int pos, u8_t *pat)
    217186{
    218187        u8_t buf[4];
    219188        int i;
    220         int r;
    221 
    222         outb_reg0(dep, DP_ISR, 0xFF);
    223 
     189       
     190        outb_reg0(dep, DP_ISR, 0xff);
     191       
    224192        /* Setup a transfer to put the pattern. */
    225193        outb_reg0(dep, DP_RBCR0, 4);
    226194        outb_reg0(dep, DP_RBCR1, 0);
    227         outb_reg0(dep, DP_RSAR0, pos &0xFF);
     195        outb_reg0(dep, DP_RSAR0, pos & 0xff);
    228196        outb_reg0(dep, DP_RSAR1, pos >> 8);
    229197        outb_reg0(dep, DP_CR, CR_DM_RW | CR_PS_P0 | CR_STA);
    230 
    231         for (i= 0; i<4; i++)
     198       
     199        for (i = 0; i < 4; i++)
    232200                outb_ne(dep, NE_DATA, pat[i]);
    233 
    234         for (i= 0; i<N; i++)
    235         {
     201       
     202        for (i = 0; i < N; i++) {
     203                if (inb_reg0(dep, DP_ISR) & ISR_RDC)
     204                        break;
     205        }
     206       
     207        if (i == N) {
     208                printf("%s: NE1000 remote DMA test failed\n", dep->de_name);
     209                return 0;
     210        }
     211       
     212        outb_reg0(dep, DP_RBCR0, 4);
     213        outb_reg0(dep, DP_RBCR1, 0);
     214        outb_reg0(dep, DP_RSAR0, pos & 0xff);
     215        outb_reg0(dep, DP_RSAR1, pos >> 8);
     216        outb_reg0(dep, DP_CR, CR_DM_RR | CR_PS_P0 | CR_STA);
     217       
     218        for (i = 0; i < 4; i++)
     219                buf[i] = inb_ne(dep, NE_DATA);
     220       
     221        return (memcmp(buf, pat, 4) == 0);
     222}
     223
     224static int test_16(dpeth_t *dep, int pos, u8_t *pat)
     225{
     226        u8_t buf[4];
     227        int i;
     228       
     229        outb_reg0(dep, DP_ISR, 0xff);
     230       
     231        /* Setup a transfer to put the pattern. */
     232        outb_reg0(dep, DP_RBCR0, 4);
     233        outb_reg0(dep, DP_RBCR1, 0);
     234        outb_reg0(dep, DP_RSAR0, pos & 0xff);
     235        outb_reg0(dep, DP_RSAR1, pos >> 8);
     236        outb_reg0(dep, DP_CR, CR_DM_RW | CR_PS_P0 | CR_STA);
     237       
     238        for (i = 0; i < 4; i += 2)
     239                outw_ne(dep, NE_DATA, *(u16_t *)(pat + i));
     240       
     241        for (i = 0; i < N; i++) {
    236242                if (inb_reg0(dep, DP_ISR) &ISR_RDC)
    237243                        break;
    238244        }
    239         if (i == N)
    240         {
    241                 if (debug)
    242                 {
    243                         printf("%s: NE1000 remote DMA test failed\n",
    244                                 dep->de_name);
    245                 }
     245       
     246        if (i == N) {
     247                printf("%s: NE2000 remote DMA test failed\n", dep->de_name);
    246248                return 0;
    247249        }
    248 
    249         outb_reg0(dep, DP_RBCR0, 4);
    250         outb_reg0(dep, DP_RBCR1, 0);
    251         outb_reg0(dep, DP_RSAR0, pos &0xFF);
     250       
     251        outb_reg0(dep, DP_RBCR0, 4);
     252        outb_reg0(dep, DP_RBCR1, 0);
     253        outb_reg0(dep, DP_RSAR0, pos & 0xff);
    252254        outb_reg0(dep, DP_RSAR1, pos >> 8);
    253255        outb_reg0(dep, DP_CR, CR_DM_RR | CR_PS_P0 | CR_STA);
    254 
    255         for (i= 0; i<4; i++)
    256                 buf[i]= inb_ne(dep, NE_DATA);
    257 
    258         r= (memcmp(buf, pat, 4) == 0);
    259         return r;
    260 }
    261 
    262 /*===========================================================================*
    263  *                              test_16                                      *
    264  *===========================================================================*/
    265 static int test_16(dep, pos, pat)
    266 dpeth_t *dep;
    267 int pos;
    268 u8_t *pat;
    269 {
    270         u8_t buf[4];
    271         int i;
    272         int r;
    273 
    274         outb_reg0(dep, DP_ISR, 0xFF);
    275 
    276         /* Setup a transfer to put the pattern. */
    277         outb_reg0(dep, DP_RBCR0, 4);
    278         outb_reg0(dep, DP_RBCR1, 0);
    279         outb_reg0(dep, DP_RSAR0, pos &0xFF);
    280         outb_reg0(dep, DP_RSAR1, pos >> 8);
    281         outb_reg0(dep, DP_CR, CR_DM_RW | CR_PS_P0 | CR_STA);
    282 
    283         for (i= 0; i<4; i += 2)
    284         {
    285                 outw_ne(dep, NE_DATA, *(u16_t *)(pat+i));
    286         }
    287 
    288         for (i= 0; i<N; i++)
    289         {
    290                 if (inb_reg0(dep, DP_ISR) &ISR_RDC)
    291                         break;
    292         }
    293         if (i == N)
    294         {
    295                 if (debug)
    296                 {
    297                         printf("%s: NE2000 remote DMA test failed\n",
    298                                 dep->de_name);
    299                 }
    300                 return 0;
    301         }
    302 
    303         outb_reg0(dep, DP_RBCR0, 4);
    304         outb_reg0(dep, DP_RBCR1, 0);
    305         outb_reg0(dep, DP_RSAR0, pos &0xFF);
    306         outb_reg0(dep, DP_RSAR1, pos >> 8);
    307         outb_reg0(dep, DP_CR, CR_DM_RR | CR_PS_P0 | CR_STA);
    308 
    309         for (i= 0; i<4; i += 2)
    310         {
    311                 *(u16_t *)(buf+i)= inw_ne(dep, NE_DATA);
    312         }
    313 
    314         r= (memcmp(buf, pat, 4) == 0);
    315         return r;
    316 }
    317 
    318 /*===========================================================================*
    319  *                              ne_stop                                      *
    320  *===========================================================================*/
    321 static void ne_stop(dep)
    322 dpeth_t *dep;
    323 {
    324         int byte;
    325 
     256       
     257        for (i = 0; i < 4; i += 2)
     258                *(u16_t *)(buf + i) = inw_ne(dep, NE_DATA);
     259       
     260        return (memcmp(buf, pat, 4) == 0);
     261}
     262
     263static void ne_stop(dpeth_t *dep)
     264{
    326265        /* Reset the ethernet card */
    327         byte= inb_ne(dep, NE_RESET);
    328         milli_delay(2);
     266        int byte = inb_ne(dep, NE_RESET);
     267        usleep(2000);
    329268        outb_ne(dep, NE_RESET, byte);
    330269}

  • uspace/srv/hw/netif/dp8390/ne2000.h

    rd3c9b60 r506a805  
    1616/** DP8390 register offset.
    1717 */
    18 #define NE_DP8390       0x00
     18#define NE_DP8390  0x00
    1919
    2020/** Data register.
    2121 */
    22 #define NE_DATA         0x10
     22#define NE_DATA  0x10
    2323
    2424/** Reset register.
    2525 */
    26 #define NE_RESET        0x1F
     26#define NE_RESET  0x1f
    2727
    2828/** NE1000 data start.
    2929 */
    30 #define NE1000_START    0x2000
     30#define NE1000_START  0x2000
    3131
    3232/** NE1000 data size.
    3333 */
    34 #define NE1000_SIZE     0x2000
     34#define NE1000_SIZE  0x2000
    3535
    3636/** NE2000 data start.
    3737 */
    38 #define NE2000_START    0x4000
     38#define NE2000_START  0x4000
    3939
    4040/** NE2000 data size.
    4141 */
    42 #define NE2000_SIZE     0x4000
     42#define NE2000_SIZE  0x4000
    4343
    4444/** Reads 1 byte register.
    … …  
    4747 *  @returns The read value.
    4848 */
    49 #define inb_ne(dep, reg)        (inb(dep->de_base_port+reg))
     49#define inb_ne(dep, reg)  (inb(dep->de_base_port + reg))
    5050
    5151/** Writes 1 byte register.
    … …  
    5454 *  @param[in] data The value to be written.
    5555 */
    56 #define outb_ne(dep, reg, data) (outb(dep->de_base_port+reg, data))
     56#define outb_ne(dep, reg, data)  (outb(dep->de_base_port + reg, data))
    5757
    5858/** Reads 1 word (2 bytes) register.
    … …  
    6161 *  @returns The read value.
    6262 */
    63 #define inw_ne(dep, reg)        (inw(dep->de_base_port+reg))
     63#define inw_ne(dep, reg)  (inw(dep->de_base_port+reg))
    6464
    6565/** Writes 1 word (2 bytes) register.
    … …  
    6868 *  @param[in] data The value to be written.
    6969 */
    70 #define outw_ne(dep, reg, data) (outw(dep->de_base_port+reg, data))
     70#define outw_ne(dep, reg, data)  (outw(dep->de_base_port+reg, data))
    7171
    72 #endif /* __NET_NETIF_NE2000_H__ */
     72#endif
    7373
    7474/** @}
Note: See TracChangeset for help on using the changeset viewer.