Changeset 85e87f1 in rtems


Ignore:
Timestamp:
Sep 9, 2008, 1:20:04 PM (11 years ago)
Author:
Thomas Doerfler <Thomas.Doerfler@…>
Branches:
4.10, 4.11, 4.9, master
Children:
1457add
Parents:
39dfbe16
Message:

added printk support
added port init, added phy support
init mmu

Location:
c/src/lib/libbsp/powerpc/tqm8xx
Files:
3 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/powerpc/tqm8xx/ChangeLog

    r39dfbe16 r85e87f1  
     12008-09-09      Thomas Doerfler <Thomas.Doerfler@embedded-brains.de>
     2
     3        * console/console.c: added printk support
     4
     5        * network/network_fec.c: added port init, added phy support
     6
     7        * irq/irq_init.c, irq/irq_asm.S, irq/irq.h: remove obsolete files
     8
     9        * startup/cpuinit.c, startup/bspstart.c: initialize mmu
     10
     11        * include/coverhd.h: update values
     12
    1132008-09-08      Joel Sherrill <joel.sherrill@oarcorp.com>
    214
  • c/src/lib/libbsp/powerpc/tqm8xx/console/console.c

    r39dfbe16 r85e87f1  
    101101#define CONS_CHN_SMC1 4
    102102#define CONS_CHN_SMC2 5
     103#define CONS_CHN_NONE -1
    103104
    104105/*
     
    115116#define MAX_IDL_DEFAULT 10
    116117#define DEVICEPREFIX "tty"
    117 
    118 /*
    119  * printk basic support
    120  */
    121 static void _BSP_null_char( char c ) {return;}
    122 BSP_output_char_function_type BSP_output_char = _BSP_null_char;
    123118
    124119/*
     
    819814sccPollWrite (int minor, const char *buf, int len)
    820815{
     816  static char txBuf[CONS_CHN_CNT][SCC_TXBD_CNT];
    821817  int chan = minor;
    822818  int bd_used;
    823 
     819 
    824820  while (len--) {
    825     static char txBuf[CONS_CHN_CNT][SCC_TXBD_CNT];
    826821    while (sccPrepTxBd[chan]->status & M8xx_BD_READY)
    827822      continue;
     
    845840  return 0;
    846841}
     842
     843/*
     844 * printk basic support
     845 */
     846int BSP_output_chan = CONS_CHN_NONE; /* channel used for printk operation */
     847
     848static void console_debug_putc_onlcr(const char c)
     849{
     850  rtems_interrupt_level irq_level;
     851  static char cr_chr = '\r';
     852
     853  if (BSP_output_chan != CONS_CHN_NONE) {
     854    rtems_interrupt_disable(irq_level);
     855   
     856    if (c == '\n') {
     857      sccPollWrite (BSP_output_chan,&cr_chr,1);
     858    }
     859    sccPollWrite (BSP_output_chan,&c,1);
     860    rtems_interrupt_enable(irq_level);
     861  }
     862}
     863
     864BSP_output_char_function_type BSP_output_char = console_debug_putc_onlcr;
     865
    847866
    848867/*
     
    931950  }
    932951  /*
    933    * FIXME: enable printk support
    934    */
     952   * enable printk support
     953   */
     954  BSP_output_chan = PRINTK_CHN;
     955
    935956  return RTEMS_SUCCESSFUL;
    936957}
     
    10291050  con360_io_trm_char_t *trm_char_info = ioa->buffer;
    10301051
    1031   printf("ioctl called: maxidl=%d\n",trm_char_info->max_idl);
    1032   printf("ioctl called: char_cnt=%d\n",trm_char_info->char_cnt);
    10331052  /*
    10341053   * check, that parameter is non-NULL
     
    10431062  if (rc == RTEMS_SUCCESSFUL) {
    10441063    if (trm_char_info->max_idl >= 0x10000) {
    1045       printf("ioctl called: invalid number for maxidl\n");
    10461064      rc = RTEMS_INVALID_NUMBER;
    10471065    }
     
    10581076  if (rc == RTEMS_SUCCESSFUL) {
    10591077    if (trm_char_info->char_cnt > CON8XX_TRM_CHAR_CNT) {
    1060       printf("ioctl called: invalid number for char_cnt\n");
    10611078      rc = RTEMS_TOO_MANY;
    10621079    }
     
    10671084      if ((rc == RTEMS_SUCCESSFUL) &&
    10681085          !m8xx_console_chan_desc[minor].is_scc) {
    1069         printf("ioctl called: not an scc:%d\n",minor);
    10701086        rc = RTEMS_UNSATISFIED;
    10711087      }
     
    10841100  }
    10851101
    1086   printf("ioctl called: return code: %d\n",rc);
    10871102  return rc;
    10881103}
  • c/src/lib/libbsp/powerpc/tqm8xx/include/coverhd.h

    r39dfbe16 r85e87f1  
    3232#endif
    3333
    34 #if ( defined(mbx821_001) || defined(mbx821_001b) || defined(mbx860_001b) )
    35 #if defined( INSTRUCTION_CACHE_ENABLE )
    3634/*
    37  * 50 MHz processor, cache enabled.
     35 * 133 MHz processor, cache enabled.
    3836 */
    3937#define CALLING_OVERHEAD_INITIALIZE_EXECUTIVE      0
     
    112110#define CALLING_OVERHEAD_MULTIPROCESSING_ANNOUNCE  0
    113111
    114 #else
    115 /*
    116  * 50 MHz processor, cache disabled.
    117  */
    118 #define CALLING_OVERHEAD_INITIALIZE_EXECUTIVE      4
    119 #define CALLING_OVERHEAD_SHUTDOWN_EXECUTIVE        4
    120 #define CALLING_OVERHEAD_TASK_CREATE               7
    121 #define CALLING_OVERHEAD_TASK_IDENT                6
    122 #define CALLING_OVERHEAD_TASK_START                5
    123 #define CALLING_OVERHEAD_TASK_RESTART              5
    124 #define CALLING_OVERHEAD_TASK_DELETE               4
    125 #define CALLING_OVERHEAD_TASK_SUSPEND              4
    126 #define CALLING_OVERHEAD_TASK_RESUME               4
    127 #define CALLING_OVERHEAD_TASK_SET_PRIORITY         5
    128 #define CALLING_OVERHEAD_TASK_MODE                 5
    129 #define CALLING_OVERHEAD_TASK_GET_NOTE             5
    130 #define CALLING_OVERHEAD_TASK_SET_NOTE             5
    131 #define CALLING_OVERHEAD_TASK_WAKE_WHEN           19
    132 #define CALLING_OVERHEAD_TASK_WAKE_AFTER           4
    133 #define CALLING_OVERHEAD_INTERRUPT_CATCH           5
    134 #define CALLING_OVERHEAD_CLOCK_GET                20
    135 #define CALLING_OVERHEAD_CLOCK_SET                19
    136 #define CALLING_OVERHEAD_CLOCK_TICK                3
    137 
    138 #define CALLING_OVERHEAD_TIMER_CREATE              5
    139 #define CALLING_OVERHEAD_TIMER_IDENT               4
    140 #define CALLING_OVERHEAD_TIMER_DELETE              5
    141 #define CALLING_OVERHEAD_TIMER_FIRE_AFTER          6
    142 #define CALLING_OVERHEAD_TIMER_FIRE_WHEN          21
    143 #define CALLING_OVERHEAD_TIMER_RESET               4
    144 #define CALLING_OVERHEAD_TIMER_CANCEL              4
    145 #define CALLING_OVERHEAD_SEMAPHORE_CREATE          6
    146 #define CALLING_OVERHEAD_SEMAPHORE_IDENT           4
    147 #define CALLING_OVERHEAD_SEMAPHORE_DELETE          6
    148 #define CALLING_OVERHEAD_SEMAPHORE_OBTAIN          5
    149 #define CALLING_OVERHEAD_SEMAPHORE_RELEASE         4
    150 #define CALLING_OVERHEAD_MESSAGE_QUEUE_CREATE      6
    151 #define CALLING_OVERHEAD_MESSAGE_QUEUE_IDENT       6
    152 #define CALLING_OVERHEAD_MESSAGE_QUEUE_DELETE      4
    153 #define CALLING_OVERHEAD_MESSAGE_QUEUE_SEND        5
    154 #define CALLING_OVERHEAD_MESSAGE_QUEUE_URGENT      5
    155 #define CALLING_OVERHEAD_MESSAGE_QUEUE_BROADCAST   5
    156 #define CALLING_OVERHEAD_MESSAGE_QUEUE_RECEIVE     6
    157 #define CALLING_OVERHEAD_MESSAGE_QUEUE_FLUSH       5
    158 
    159 #define CALLING_OVERHEAD_EVENT_SEND                5
    160 #define CALLING_OVERHEAD_EVENT_RECEIVE             5
    161 #define CALLING_OVERHEAD_SIGNAL_CATCH              4
    162 #define CALLING_OVERHEAD_SIGNAL_SEND               5
    163 #define CALLING_OVERHEAD_PARTITION_CREATE          7
    164 #define CALLING_OVERHEAD_PARTITION_IDENT           6
    165 #define CALLING_OVERHEAD_PARTITION_DELETE          4
    166 #define CALLING_OVERHEAD_PARTITION_GET_BUFFER      5
    167 #define CALLING_OVERHEAD_PARTITION_RETURN_BUFFER   5
    168 #define CALLING_OVERHEAD_REGION_CREATE             7
    169 #define CALLING_OVERHEAD_REGION_IDENT              5
    170 #define CALLING_OVERHEAD_REGION_DELETE             4
    171 #define CALLING_OVERHEAD_REGION_GET_SEGMENT        6
    172 #define CALLING_OVERHEAD_REGION_RETURN_SEGMENT     5
    173 #define CALLING_OVERHEAD_PORT_CREATE               6
    174 #define CALLING_OVERHEAD_PORT_IDENT                5
    175 #define CALLING_OVERHEAD_PORT_DELETE               4
    176 #define CALLING_OVERHEAD_PORT_EXTERNAL_TO_INTERNAL 6
    177 #define CALLING_OVERHEAD_PORT_INTERNAL_TO_EXTERNAL 6
    178 
    179 #define CALLING_OVERHEAD_IO_INITIALIZE             6
    180 #define CALLING_OVERHEAD_IO_OPEN                   6
    181 #define CALLING_OVERHEAD_IO_CLOSE                  6
    182 #define CALLING_OVERHEAD_IO_READ                   6
    183 #define CALLING_OVERHEAD_IO_WRITE                  6
    184 #define CALLING_OVERHEAD_IO_CONTROL                6
    185 #define CALLING_OVERHEAD_FATAL_ERROR_OCCURRED      4
    186 #define CALLING_OVERHEAD_RATE_MONOTONIC_CREATE     5
    187 #define CALLING_OVERHEAD_RATE_MONOTONIC_IDENT      5
    188 #define CALLING_OVERHEAD_RATE_MONOTONIC_DELETE     4
    189 #define CALLING_OVERHEAD_RATE_MONOTONIC_CANCEL     4
    190 #define CALLING_OVERHEAD_RATE_MONOTONIC_PERIOD     5
    191 #define CALLING_OVERHEAD_MULTIPROCESSING_ANNOUNCE  3
    192 
    193 #endif /* defined( INSTRUCTION_CACHE_ENABLE ) */
    194 
    195 #else
    196 #if defined( INSTRUCTION_CACHE_ENABLE )
    197 /*
    198  * 40 MHz processor, cache enabled.
    199  */
    200 #define CALLING_OVERHEAD_INITIALIZE_EXECUTIVE      0
    201 #define CALLING_OVERHEAD_SHUTDOWN_EXECUTIVE        1
    202 #define CALLING_OVERHEAD_TASK_CREATE               1
    203 #define CALLING_OVERHEAD_TASK_IDENT                0
    204 #define CALLING_OVERHEAD_TASK_START                0
    205 #define CALLING_OVERHEAD_TASK_RESTART              0
    206 #define CALLING_OVERHEAD_TASK_DELETE               0
    207 #define CALLING_OVERHEAD_TASK_SUSPEND              0
    208 #define CALLING_OVERHEAD_TASK_RESUME               0
    209 #define CALLING_OVERHEAD_TASK_SET_PRIORITY         0
    210 #define CALLING_OVERHEAD_TASK_MODE                 0
    211 #define CALLING_OVERHEAD_TASK_GET_NOTE             0
    212 #define CALLING_OVERHEAD_TASK_SET_NOTE             0
    213 #define CALLING_OVERHEAD_TASK_WAKE_WHEN            1
    214 #define CALLING_OVERHEAD_TASK_WAKE_AFTER           0
    215 #define CALLING_OVERHEAD_INTERRUPT_CATCH           0
    216 #define CALLING_OVERHEAD_CLOCK_GET                 1
    217 #define CALLING_OVERHEAD_CLOCK_SET                 1
    218 #define CALLING_OVERHEAD_CLOCK_TICK                0
    219 
    220 #define CALLING_OVERHEAD_TIMER_CREATE              0
    221 #define CALLING_OVERHEAD_TIMER_IDENT               0
    222 #define CALLING_OVERHEAD_TIMER_DELETE              0
    223 #define CALLING_OVERHEAD_TIMER_FIRE_AFTER          0
    224 #define CALLING_OVERHEAD_TIMER_FIRE_WHEN           1
    225 #define CALLING_OVERHEAD_TIMER_RESET               0
    226 #define CALLING_OVERHEAD_TIMER_CANCEL              0
    227 #define CALLING_OVERHEAD_SEMAPHORE_CREATE          0
    228 #define CALLING_OVERHEAD_SEMAPHORE_IDENT           0
    229 #define CALLING_OVERHEAD_SEMAPHORE_DELETE          0
    230 #define CALLING_OVERHEAD_SEMAPHORE_OBTAIN          0
    231 #define CALLING_OVERHEAD_SEMAPHORE_RELEASE         0
    232 #define CALLING_OVERHEAD_MESSAGE_QUEUE_CREATE      0
    233 #define CALLING_OVERHEAD_MESSAGE_QUEUE_IDENT       0
    234 #define CALLING_OVERHEAD_MESSAGE_QUEUE_DELETE      0
    235 #define CALLING_OVERHEAD_MESSAGE_QUEUE_SEND        0
    236 #define CALLING_OVERHEAD_MESSAGE_QUEUE_URGENT      0
    237 #define CALLING_OVERHEAD_MESSAGE_QUEUE_BROADCAST   0
    238 #define CALLING_OVERHEAD_MESSAGE_QUEUE_RECEIVE     0
    239 #define CALLING_OVERHEAD_MESSAGE_QUEUE_FLUSH       0
    240 
    241 #define CALLING_OVERHEAD_EVENT_SEND                0
    242 #define CALLING_OVERHEAD_EVENT_RECEIVE             0
    243 #define CALLING_OVERHEAD_SIGNAL_CATCH              0
    244 #define CALLING_OVERHEAD_SIGNAL_SEND               0
    245 #define CALLING_OVERHEAD_PARTITION_CREATE          1
    246 #define CALLING_OVERHEAD_PARTITION_IDENT           0
    247 #define CALLING_OVERHEAD_PARTITION_DELETE          0
    248 #define CALLING_OVERHEAD_PARTITION_GET_BUFFER      0
    249 #define CALLING_OVERHEAD_PARTITION_RETURN_BUFFER   0
    250 #define CALLING_OVERHEAD_REGION_CREATE             1
    251 #define CALLING_OVERHEAD_REGION_IDENT              0
    252 #define CALLING_OVERHEAD_REGION_DELETE             0
    253 #define CALLING_OVERHEAD_REGION_GET_SEGMENT        0
    254 #define CALLING_OVERHEAD_REGION_RETURN_SEGMENT     0
    255 #define CALLING_OVERHEAD_PORT_CREATE               2
    256 #define CALLING_OVERHEAD_PORT_IDENT                0
    257 #define CALLING_OVERHEAD_PORT_DELETE               0
    258 #define CALLING_OVERHEAD_PORT_EXTERNAL_TO_INTERNAL 0
    259 #define CALLING_OVERHEAD_PORT_INTERNAL_TO_EXTERNAL 0
    260 
    261 #define CALLING_OVERHEAD_IO_INITIALIZE             0
    262 #define CALLING_OVERHEAD_IO_OPEN                   0
    263 #define CALLING_OVERHEAD_IO_CLOSE                  0
    264 #define CALLING_OVERHEAD_IO_READ                   0
    265 #define CALLING_OVERHEAD_IO_WRITE                  0
    266 #define CALLING_OVERHEAD_IO_CONTROL                0
    267 #define CALLING_OVERHEAD_FATAL_ERROR_OCCURRED      0
    268 #define CALLING_OVERHEAD_RATE_MONOTONIC_CREATE     0
    269 #define CALLING_OVERHEAD_RATE_MONOTONIC_IDENT      0
    270 #define CALLING_OVERHEAD_RATE_MONOTONIC_DELETE     0
    271 #define CALLING_OVERHEAD_RATE_MONOTONIC_CANCEL     0
    272 #define CALLING_OVERHEAD_RATE_MONOTONIC_PERIOD     0
    273 #define CALLING_OVERHEAD_MULTIPROCESSING_ANNOUNCE  0
    274 
    275 #else
    276 /*
    277  * 40 MHz processor, cache disabled.
    278  */
    279 #define CALLING_OVERHEAD_INITIALIZE_EXECUTIVE      4
    280 #define CALLING_OVERHEAD_SHUTDOWN_EXECUTIVE        3
    281 #define CALLING_OVERHEAD_TASK_CREATE               6
    282 #define CALLING_OVERHEAD_TASK_IDENT                5
    283 #define CALLING_OVERHEAD_TASK_START                5
    284 #define CALLING_OVERHEAD_TASK_RESTART              4
    285 #define CALLING_OVERHEAD_TASK_DELETE               4
    286 #define CALLING_OVERHEAD_TASK_SUSPEND              4
    287 #define CALLING_OVERHEAD_TASK_RESUME               4
    288 #define CALLING_OVERHEAD_TASK_SET_PRIORITY         5
    289 #define CALLING_OVERHEAD_TASK_MODE                 4
    290 #define CALLING_OVERHEAD_TASK_GET_NOTE             5
    291 #define CALLING_OVERHEAD_TASK_SET_NOTE             5
    292 #define CALLING_OVERHEAD_TASK_WAKE_WHEN           17
    293 #define CALLING_OVERHEAD_TASK_WAKE_AFTER           3
    294 #define CALLING_OVERHEAD_INTERRUPT_CATCH           5
    295 #define CALLING_OVERHEAD_CLOCK_GET                17
    296 #define CALLING_OVERHEAD_CLOCK_SET                17
    297 #define CALLING_OVERHEAD_CLOCK_TICK                3
    298 
    299 #define CALLING_OVERHEAD_TIMER_CREATE              4
    300 #define CALLING_OVERHEAD_TIMER_IDENT               4
    301 #define CALLING_OVERHEAD_TIMER_DELETE              5
    302 #define CALLING_OVERHEAD_TIMER_FIRE_AFTER          5
    303 #define CALLING_OVERHEAD_TIMER_FIRE_WHEN          19
    304 #define CALLING_OVERHEAD_TIMER_RESET               4
    305 #define CALLING_OVERHEAD_TIMER_CANCEL              4
    306 #define CALLING_OVERHEAD_SEMAPHORE_CREATE          6
    307 #define CALLING_OVERHEAD_SEMAPHORE_IDENT           4
    308 #define CALLING_OVERHEAD_SEMAPHORE_DELETE          5
    309 #define CALLING_OVERHEAD_SEMAPHORE_OBTAIN          5
    310 #define CALLING_OVERHEAD_SEMAPHORE_RELEASE         4
    311 #define CALLING_OVERHEAD_MESSAGE_QUEUE_CREATE      5
    312 #define CALLING_OVERHEAD_MESSAGE_QUEUE_IDENT       5
    313 #define CALLING_OVERHEAD_MESSAGE_QUEUE_DELETE      4
    314 #define CALLING_OVERHEAD_MESSAGE_QUEUE_SEND        4
    315 #define CALLING_OVERHEAD_MESSAGE_QUEUE_URGENT      4
    316 #define CALLING_OVERHEAD_MESSAGE_QUEUE_BROADCAST   5
    317 #define CALLING_OVERHEAD_MESSAGE_QUEUE_RECEIVE     5
    318 #define CALLING_OVERHEAD_MESSAGE_QUEUE_FLUSH       4
    319 
    320 #define CALLING_OVERHEAD_EVENT_SEND                5
    321 #define CALLING_OVERHEAD_EVENT_RECEIVE             5
    322 #define CALLING_OVERHEAD_SIGNAL_CATCH              4
    323 #define CALLING_OVERHEAD_SIGNAL_SEND               4
    324 #define CALLING_OVERHEAD_PARTITION_CREATE          6
    325 #define CALLING_OVERHEAD_PARTITION_IDENT           5
    326 #define CALLING_OVERHEAD_PARTITION_DELETE          4
    327 #define CALLING_OVERHEAD_PARTITION_GET_BUFFER      5
    328 #define CALLING_OVERHEAD_PARTITION_RETURN_BUFFER   5
    329 #define CALLING_OVERHEAD_REGION_CREATE             6
    330 #define CALLING_OVERHEAD_REGION_IDENT              5
    331 #define CALLING_OVERHEAD_REGION_DELETE             4
    332 #define CALLING_OVERHEAD_REGION_GET_SEGMENT        6
    333 #define CALLING_OVERHEAD_REGION_RETURN_SEGMENT     5
    334 #define CALLING_OVERHEAD_PORT_CREATE               6
    335 #define CALLING_OVERHEAD_PORT_IDENT                5
    336 #define CALLING_OVERHEAD_PORT_DELETE               4
    337 #define CALLING_OVERHEAD_PORT_EXTERNAL_TO_INTERNAL 5
    338 #define CALLING_OVERHEAD_PORT_INTERNAL_TO_EXTERNAL 5
    339 
    340 #define CALLING_OVERHEAD_IO_INITIALIZE             5
    341 #define CALLING_OVERHEAD_IO_OPEN                   5
    342 #define CALLING_OVERHEAD_IO_CLOSE                  5
    343 #define CALLING_OVERHEAD_IO_READ                   5
    344 #define CALLING_OVERHEAD_IO_WRITE                  5
    345 #define CALLING_OVERHEAD_IO_CONTROL                5
    346 #define CALLING_OVERHEAD_FATAL_ERROR_OCCURRED      3
    347 #define CALLING_OVERHEAD_RATE_MONOTONIC_CREATE     4
    348 #define CALLING_OVERHEAD_RATE_MONOTONIC_IDENT      5
    349 #define CALLING_OVERHEAD_RATE_MONOTONIC_DELETE     4
    350 #define CALLING_OVERHEAD_RATE_MONOTONIC_CANCEL     4
    351 #define CALLING_OVERHEAD_RATE_MONOTONIC_PERIOD     4
    352 #define CALLING_OVERHEAD_MULTIPROCESSING_ANNOUNCE  3
    353 
    354 #endif /* defined( INSTRUCTION_CACHE_ENABLE ) */
    355 
    356 #endif
    357 
    358112#ifdef __cplusplus
    359113}
  • c/src/lib/libbsp/powerpc/tqm8xx/network/network_fec.c

    r39dfbe16 r85e87f1  
    5555#include <rtems/error.h>
    5656#include <rtems/rtems_bsdnet.h>
     57#include <rtems/rtems_mii_ioctl.h>
    5758
    5859#include <sys/param.h>
     
    111112#endif
    112113
     114#define FEC_WATCHDOG_TIMEOUT 5 /* check media every 5 seconds */
    113115/*
    114116 * Per-device data
     
    130132
    131133  /*
     134   * MDIO/Phy info
     135   */
     136  struct rtems_mdio_info mdio_info;
     137  int phy_default;
     138  int media_state; /* (last detected) state of media */
     139  /*
    132140   * Statistics
    133141   */
     
    153161static struct m8xx_fec_enet_struct enet_driver[NIFACES];
    154162
     163/* declare ioctl function for internal use */
     164static int fec_ioctl (struct ifnet *ifp,
     165                      ioctl_command_t command, caddr_t data);
     166/***************************************************************************\
     167|  MII Management access functions                                          |
     168\***************************************************************************/
     169
     170/*=========================================================================*\
     171| Function:                                                                 |
     172\*-------------------------------------------------------------------------*/
     173static void fec_mdio_init
     174(
     175/*-------------------------------------------------------------------------*\
     176| Purpose:                                                                  |
     177|   initialize the MII interface                                            |
     178+---------------------------------------------------------------------------+
     179| Input Parameters:                                                         |
     180\*-------------------------------------------------------------------------*/
     181 struct m8xx_fec_enet_struct *sc     /* control structure                */
     182)
     183/*-------------------------------------------------------------------------*\
     184| Return Value:                                                             |
     185|    <none>                                                                 |
     186\*=========================================================================*/
     187{
     188
     189  /* Set FEC registers for MDIO communication */
     190  /*
     191   * set clock divider
     192   */
     193  m8xx.fec.mii_speed = BSP_bus_frequency / 25000000 / 2 + 1;
     194}
     195
     196/*=========================================================================*\
     197| Function:                                                                 |
     198\*-------------------------------------------------------------------------*/
     199int fec_mdio_read
     200(
     201/*-------------------------------------------------------------------------*\
     202| Purpose:                                                                  |
     203|   read register of a phy                                                  |
     204+---------------------------------------------------------------------------+
     205| Input Parameters:                                                         |
     206\*-------------------------------------------------------------------------*/
     207 int phy,                              /* PHY number to access or -1       */
     208 void *uarg,                           /* unit argument                    */
     209 unsigned reg,                         /* register address                 */
     210 uint32_t *pval                        /* ptr to read buffer               */
     211 )
     212/*-------------------------------------------------------------------------*\
     213| Return Value:                                                             |
     214|    0, if ok, else error                                                   |
     215\*=========================================================================*/
     216{
     217  struct m8xx_fec_enet_struct *sc = uarg;/* control structure            */
     218
     219  /*
     220   * make sure we work with a valid phy
     221   */
     222  if (phy == -1) {
     223    /*
     224     * set default phy number: 0
     225     */
     226    phy = sc->phy_default;
     227  }
     228  if ( (phy < 0) || (phy > 31)) {
     229    /*
     230     * invalid phy number
     231     */
     232    return EINVAL;
     233  }
     234  /*
     235   * clear MII transfer event bit
     236   */
     237  m8xx.fec.ievent = M8xx_FEC_IEVENT_MII;
     238  /*
     239   * set access command, data, start transfer
     240   */
     241  m8xx.fec.mii_data = (M8xx_FEC_MII_DATA_ST    |
     242                       M8xx_FEC_MII_DATA_OP_RD |
     243                       M8xx_FEC_MII_DATA_PHYAD(phy) |
     244                       M8xx_FEC_MII_DATA_PHYRA(reg) |
     245                       M8xx_FEC_MII_DATA_WDATA(0));
     246
     247  /*
     248   * wait for cycle to terminate
     249   */
     250  do {
     251    rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
     252  }  while (0 == (m8xx.fec.ievent & M8xx_FEC_IEVENT_MII));
     253
     254  /*
     255   * fetch read data, if available
     256   */
     257  if (pval != NULL) {
     258    *pval = M8xx_FEC_MII_DATA_RDATA(m8xx.fec.mii_data);
     259  }
     260  return 0;
     261}
     262
     263/*=========================================================================*\
     264| Function:                                                                 |
     265\*-------------------------------------------------------------------------*/
     266int fec_mdio_write
     267(
     268/*-------------------------------------------------------------------------*\
     269| Purpose:                                                                  |
     270|   write register of a phy                                                 |
     271+---------------------------------------------------------------------------+
     272| Input Parameters:                                                         |
     273\*-------------------------------------------------------------------------*/
     274 int phy,                              /* PHY number to access or -1       */
     275 void *uarg,                           /* unit argument                    */
     276 unsigned reg,                         /* register address                 */
     277 uint32_t val                          /* write value                      */
     278 )
     279/*-------------------------------------------------------------------------*\
     280| Return Value:                                                             |
     281|    0, if ok, else error                                                   |
     282\*=========================================================================*/
     283{
     284  struct m8xx_fec_enet_struct *sc = uarg;/* control structure            */
     285
     286  /*
     287   * make sure we work with a valid phy
     288   */
     289  if (phy == -1) {
     290    /*
     291     * set default phy number: 0
     292     */
     293    phy = sc->phy_default;
     294  }
     295  if ( (phy < 0) || (phy > 31)) {
     296    /*
     297     * invalid phy number
     298     */
     299    return EINVAL;
     300  }
     301  /*
     302   * clear MII transfer event bit
     303   */
     304  m8xx.fec.ievent = M8xx_FEC_IEVENT_MII;
     305  /*
     306   * set access command, data, start transfer
     307   */
     308  m8xx.fec.mii_data = (M8xx_FEC_MII_DATA_ST    |
     309                       M8xx_FEC_MII_DATA_OP_WR |
     310                       M8xx_FEC_MII_DATA_PHYAD(phy) |
     311                       M8xx_FEC_MII_DATA_PHYRA(reg) |
     312                       M8xx_FEC_MII_DATA_WDATA(val));
     313
     314  /*
     315   * wait for cycle to terminate
     316   */
     317  do {
     318    rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
     319  }  while (0 == (m8xx.fec.ievent & M8xx_FEC_IEVENT_MII));
     320
     321  return 0;
     322}
     323
    155324/*
    156325 * FEC interrupt handler
     
    287456  /*
    288457   * Set up Transmit Control Register:
    289    *   Half duplex
     458   *   Full duplex
    290459   *   No heartbeat
    291460   */
    292   m8xx.fec.x_cntrl = 0x00000000;
     461  m8xx.fec.x_cntrl = M8xx_FEC_X_CNTRL_FDEN;
    293462
    294463  /*
     
    307476   */
    308477  m8xx.sdcr = 1;
    309 
    310   /*
    311    * Set MII speed to 2.5 MHz for 25 Mhz system clock
    312    */
    313   m8xx.fec.mii_speed = 0x0a;
    314   m8xx.fec.mii_data = 0x58021000;
    315478
    316479  /*
     
    517680          enet_driver[0].txUnderrun++;
    518681
    519         /*
    520          * Restart the transmitter
    521          */
    522         /* FIXME: this should get executed only if using the SCC */
    523         m8xx_cp_execute_cmd (M8xx_CR_OP_RESTART_TX | M8xx_CR_CHAN_SCC1);
    524682      }
    525683      if (status & M8xx_BD_DEFER)
     
    716874
    717875    /*
    718      * Set up SCC hardware
     876     * Set up FEC hardware
    719877     */
    720878    m8xx_fec_initialize_hardware (sc);
     879
     880    /*
     881     * init access to phy
     882     */
     883    fec_mdio_init(sc);
    721884
    722885    /*
     
    735898  else
    736899    m8xx.fec.r_cntrl &= ~0x8;
     900
     901  /*
     902   * init timer so the "watchdog function gets called periodically
     903   */
     904  ifp->if_timer    = 1;
    737905
    738906  /*
     
    776944static void fec_enet_stats (struct m8xx_fec_enet_struct *sc)
    777945{
     946  int media;
     947  int result;
     948  /*
     949   * fetch/print media info
     950   */
     951  media = IFM_MAKEWORD(0,0,0,sc->phy_default); /* fetch from default phy */
     952
     953  result = fec_ioctl(&(sc->arpcom.ac_if),
     954                     SIOCGIFMEDIA,
     955                     (caddr_t)&media);
     956  if (result == 0) {
     957    rtems_ifmedia2str(media,NULL,0);
     958    printf ("\n");
     959  }
     960
    778961  printf ("      Rx Interrupts:%-8lu", sc->rxInterrupts);
    779962  printf ("       Not First:%-8lu", sc->rxNotFirst);
     
    785968  printf ("         Overrun:%-8lu", sc->rxOverrun);
    786969  printf ("       Collision:%-8lu\n", sc->rxCollision);
    787   printf ("          Discarded:%-8lu\n", (unsigned long)m8xx.scc1p.un.ethernet.disfc);
    788970
    789971  printf ("      Tx Interrupts:%-8lu", sc->txInterrupts);
     
    804986
    805987  switch (command) {
     988    /*
     989     * access PHY via MII
     990     */
     991  case SIOCGIFMEDIA:
     992  case SIOCSIFMEDIA:
     993    rtems_mii_ioctl (&(sc->mdio_info),sc,command,(void *)data);
     994    break;
    806995  case SIOCGIFADDR:
    807996  case SIOCSIFADDR:
     
    8421031  return error;
    8431032}
     1033
     1034/*=========================================================================*\
     1035| Function:                                                                 |
     1036\*-------------------------------------------------------------------------*/
     1037int fec_mode_adapt
     1038(
     1039/*-------------------------------------------------------------------------*\
     1040| Purpose:                                                                  |
     1041|   init the PHY and adapt FEC settings                                     |
     1042+---------------------------------------------------------------------------+
     1043| Input Parameters:                                                         |
     1044\*-------------------------------------------------------------------------*/
     1045 struct ifnet *ifp
     1046)
     1047/*-------------------------------------------------------------------------*\
     1048| Return Value:                                                             |
     1049|    0, if success                                                          |
     1050\*=========================================================================*/
     1051{
     1052  int result = 0;
     1053  struct m8xx_fec_enet_struct *sc = ifp->if_softc;
     1054  int media = IFM_MAKEWORD( 0, 0, 0, sc->phy_default);
     1055
     1056#ifdef DEBUG
     1057  printf("c");
     1058#endif
     1059  /*
     1060   * fetch media status
     1061   */
     1062  result = fec_ioctl(ifp,SIOCGIFMEDIA,(caddr_t)&media);
     1063  if (result != 0) {
     1064    return result;
     1065  }
     1066#ifdef DEBUG
     1067  printf("C");
     1068#endif
     1069  /*
     1070   * status is unchanged? then do nothing
     1071   */
     1072  if (media == sc->media_state) {
     1073    return 0;
     1074  }
     1075  /*
     1076   * otherwise: for the first call, try to negotiate mode
     1077   */
     1078  if (sc->media_state == 0) {
     1079    /*
     1080     * set media status: set auto negotiation -> start auto-negotiation
     1081     */
     1082    media = IFM_MAKEWORD(0,IFM_AUTO,0,sc->phy_default);
     1083    result = fec_ioctl(ifp,SIOCSIFMEDIA,(caddr_t)&media);
     1084    if (result != 0) {
     1085      return result;
     1086    }
     1087    /*
     1088     * wait for auto-negotiation to terminate
     1089     */
     1090    do {
     1091      media = IFM_MAKEWORD(0,0,0,sc->phy_default);
     1092      result = fec_ioctl(ifp,SIOCGIFMEDIA,(caddr_t)&media);
     1093      if (result != 0) {
     1094        return result;
     1095      }
     1096    } while (IFM_NONE == IFM_SUBTYPE(media));
     1097  }
     1098
     1099  /*
     1100   * now set HW according to media results:
     1101   */
     1102  /*
     1103   * if we are half duplex then switch to half duplex
     1104   */
     1105  if (0 == (IFM_FDX & IFM_OPTIONS(media))) {
     1106    m8xx.fec.x_cntrl &= ~M8xx_FEC_X_CNTRL_FDEN;
     1107  }
     1108  else {
     1109    m8xx.fec.x_cntrl |=  M8xx_FEC_X_CNTRL_FDEN;
     1110  }   
     1111  /*
     1112   * store current media state for future compares
     1113   */
     1114  sc->media_state = media;
     1115
     1116  return 0;
     1117}
     1118
     1119/*=========================================================================*\
     1120| Function:                                                                 |
     1121\*-------------------------------------------------------------------------*/
     1122static void fec_watchdog
     1123(
     1124/*-------------------------------------------------------------------------*\
     1125| Purpose:                                                                  |
     1126|   periodically poll the PHY. if mode has changed,                         |
     1127|  then adjust the FEC settings                                             |
     1128+---------------------------------------------------------------------------+
     1129| Input Parameters:                                                         |
     1130\*-------------------------------------------------------------------------*/
     1131 struct ifnet *ifp
     1132)
     1133/*-------------------------------------------------------------------------*\
     1134| Return Value:                                                             |
     1135|    1, if success                                                          |
     1136\*=========================================================================*/
     1137{
     1138  fec_mode_adapt(ifp);
     1139  ifp->if_timer    = FEC_WATCHDOG_TIMEOUT;
     1140}
     1141
    8441142int rtems_fec_driver_attach (struct rtems_bsdnet_ifconfig *config)
    8451143{
     
    8611159   */
    8621160  if ((unitNumber <= 0) || (unitNumber > NIFACES)) {
    863     printf ("Bad SCC unit number.\n");
     1161    printk ("Bad FEC unit number.\n");
    8641162    return 0;
    8651163  }
     
    8671165  ifp = &sc->arpcom.ac_if;
    8681166  if (ifp->if_softc != NULL) {
    869     printf ("Driver already in use.\n");
     1167    printk ("Driver already in use.\n");
    8701168    return 0;
    8711169  }
     
    9001198
    9011199  /*
     1200   * setup info about mdio interface
     1201   */
     1202  sc->mdio_info.mdio_r   = fec_mdio_read;
     1203  sc->mdio_info.mdio_w   = fec_mdio_write;
     1204  sc->mdio_info.has_gmii = 0; /* we do not support gigabit IF */
     1205  /*
     1206   * assume: IF 1 -> PHY 0
     1207   */
     1208  sc->phy_default = unitNumber-1;
     1209
     1210  /*
    9021211   * Set up network interface values
    9031212   */
     
    9101219  ifp->if_start = m8xx_fec_enet_start;
    9111220  ifp->if_output = ether_output;
     1221  ifp->if_watchdog =  fec_watchdog; /* XXX: timer is set in "init" */
    9121222  ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX;
    9131223  if (ifp->if_snd.ifq_maxlen == 0)
     
    9251235                                 int attaching)
    9261236{
     1237  /*
     1238   * enable FEC functionality at hardware pins*
     1239   * PD[3-15] are FEC pins
     1240   */
     1241  if (attaching) {
     1242    m8xx.pdpar |= 0x1fff;
     1243    m8xx.pddir |= 0x1fff;
     1244  }
    9271245  return rtems_fec_driver_attach(config);
    9281246}
  • c/src/lib/libbsp/powerpc/tqm8xx/startup/cpuinit.c

    r39dfbe16 r85e87f1  
    129129void cpu_init(void)
    130130{
    131   /*
    132    * none up to now
    133    */
     131  /* mmu initialization */
     132  mmu_init();
    134133}
Note: See TracChangeset for help on using the changeset viewer.