drivers/net/wan/lmc/lmc_media.c

   1 /* $Id: lmc_media.c,v 1.13 2000/04/11 05:25:26 asj Exp $ */
   2
   3 #include <linux/config.h>
   4 #include <linux/kernel.h>
   5 #include <linux/string.h>
   6 #include <linux/timer.h>
   7 #include <linux/ptrace.h>
   8 #include <linux/errno.h>
   9 #include <linux/ioport.h>
  10 #include <linux/slab.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/pci.h>
  13 #include <linux/in.h>
  14 #include <linux/if_arp.h>
  15 #include <linux/netdevice.h>
  16 #include <linux/etherdevice.h>
  17 #include <linux/skbuff.h>
  18 #include <linux/inet.h>
  19 #include <linux/bitops.h>
  20
  21 #include <net/syncppp.h>
  22
  23 #include <asm/processor.h>             /* Processor type for cache alignment. */
  24 #include <asm/io.h>
  25 #include <asm/dma.h>
  26
  27 #include <asm/uaccess.h>
  28
  29 #include "lmc.h"
  30 #include "lmc_var.h"
  31 #include "lmc_ioctl.h"
  32 #include "lmc_debug.h"
  33
  34 #define CONFIG_LMC_IGNORE_HARDWARE_HANDSHAKE 1
  35
  36  /*
  37   * Copyright (c) 1997-2000 LAN Media Corporation (LMC)
  38   * All rights reserved.  www.lanmedia.com
  39   *
  40   * This code is written by:
  41   * Andrew Stanley-Jones (asj@cban.com)
  42   * Rob Braun (bbraun@vix.com),
  43   * Michael Graff (explorer@vix.com) and
  44   * Matt Thomas (matt@3am-software.com).
  45   *
  46   * This software may be used and distributed according to the terms
  47   * of the GNU General Public License version 2, incorporated herein by reference.
  48   */
  49
  50 /*
  51  * protocol independent method.
  52  */
  53 static void lmc_set_protocol (lmc_softc_t * const, lmc_ctl_t *);
  54
  55 /*
  56  * media independent methods to check on media status, link, light LEDs,
  57  * etc.
  58  */
  59 static void lmc_ds3_init (lmc_softc_t * const);
  60 static void lmc_ds3_default (lmc_softc_t * const);
  61 static void lmc_ds3_set_status (lmc_softc_t * const, lmc_ctl_t *);
  62 static void lmc_ds3_set_100ft (lmc_softc_t * const, int);
  63 static int lmc_ds3_get_link_status (lmc_softc_t * const);
  64 static void lmc_ds3_set_crc_length (lmc_softc_t * const, int);
  65 static void lmc_ds3_set_scram (lmc_softc_t * const, int);
  66 static void lmc_ds3_watchdog (lmc_softc_t * const);
  67
  68 static void lmc_hssi_init (lmc_softc_t * const);
  69 static void lmc_hssi_default (lmc_softc_t * const);
  70 static void lmc_hssi_set_status (lmc_softc_t * const, lmc_ctl_t *);
  71 static void lmc_hssi_set_clock (lmc_softc_t * const, int);
  72 static int lmc_hssi_get_link_status (lmc_softc_t * const);
  73 static void lmc_hssi_set_link_status (lmc_softc_t * const, int);
  74 static void lmc_hssi_set_crc_length (lmc_softc_t * const, int);
  75 static void lmc_hssi_watchdog (lmc_softc_t * const);
  76
  77 static void lmc_ssi_init (lmc_softc_t * const);
  78 static void lmc_ssi_default (lmc_softc_t * const);
  79 static void lmc_ssi_set_status (lmc_softc_t * const, lmc_ctl_t *);
  80 static void lmc_ssi_set_clock (lmc_softc_t * const, int);
  81 static void lmc_ssi_set_speed (lmc_softc_t * const, lmc_ctl_t *);
  82 static int lmc_ssi_get_link_status (lmc_softc_t * const);
  83 static void lmc_ssi_set_link_status (lmc_softc_t * const, int);
  84 static void lmc_ssi_set_crc_length (lmc_softc_t * const, int);
  85 static void lmc_ssi_watchdog (lmc_softc_t * const);
  86
  87 static void lmc_t1_init (lmc_softc_t * const);
  88 static void lmc_t1_default (lmc_softc_t * const);
  89 static void lmc_t1_set_status (lmc_softc_t * const, lmc_ctl_t *);
  90 static int lmc_t1_get_link_status (lmc_softc_t * const);
  91 static void lmc_t1_set_circuit_type (lmc_softc_t * const, int);
  92 static void lmc_t1_set_crc_length (lmc_softc_t * const, int);
  93 static void lmc_t1_set_clock (lmc_softc_t * const, int);
  94 static void lmc_t1_watchdog (lmc_softc_t * const);
  95
  96 static void lmc_dummy_set_1 (lmc_softc_t * const, int);
  97 static void lmc_dummy_set2_1 (lmc_softc_t * const, lmc_ctl_t *);
  98
  99 static inline void write_av9110_bit (lmc_softc_t *, int);
 100 static void write_av9110 (lmc_softc_t *, u_int32_t, u_int32_t, u_int32_t,
 101                           u_int32_t, u_int32_t);
 102
 103 lmc_media_t lmc_ds3_media = {
 104   lmc_ds3_init,                 /* special media init stuff */
 105   lmc_ds3_default,              /* reset to default state */
 106   lmc_ds3_set_status,           /* reset status to state provided */
 107   lmc_dummy_set_1,              /* set clock source */
 108   lmc_dummy_set2_1,             /* set line speed */
 109   lmc_ds3_set_100ft,            /* set cable length */
 110   lmc_ds3_set_scram,            /* set scrambler */
 111   lmc_ds3_get_link_status,      /* get link status */
 112   lmc_dummy_set_1,              /* set link status */
 113   lmc_ds3_set_crc_length,       /* set CRC length */
 114   lmc_dummy_set_1,              /* set T1 or E1 circuit type */
 115   lmc_ds3_watchdog
 116 };
 117
 118 lmc_media_t lmc_hssi_media = {
 119   lmc_hssi_init,                /* special media init stuff */
 120   lmc_hssi_default,             /* reset to default state */
 121   lmc_hssi_set_status,          /* reset status to state provided */
 122   lmc_hssi_set_clock,           /* set clock source */
 123   lmc_dummy_set2_1,             /* set line speed */
 124   lmc_dummy_set_1,              /* set cable length */
 125   lmc_dummy_set_1,              /* set scrambler */
 126   lmc_hssi_get_link_status,     /* get link status */
 127   lmc_hssi_set_link_status,     /* set link status */
 128   lmc_hssi_set_crc_length,      /* set CRC length */
 129   lmc_dummy_set_1,              /* set T1 or E1 circuit type */
 130   lmc_hssi_watchdog
 131 };
 132
 133 lmc_media_t lmc_ssi_media = { lmc_ssi_init,     /* special media init stuff */
 134   lmc_ssi_default,              /* reset to default state */
 135   lmc_ssi_set_status,           /* reset status to state provided */
 136   lmc_ssi_set_clock,            /* set clock source */
 137   lmc_ssi_set_speed,            /* set line speed */
 138   lmc_dummy_set_1,              /* set cable length */
 139   lmc_dummy_set_1,              /* set scrambler */
 140   lmc_ssi_get_link_status,      /* get link status */
 141   lmc_ssi_set_link_status,      /* set link status */
 142   lmc_ssi_set_crc_length,       /* set CRC length */
 143   lmc_dummy_set_1,              /* set T1 or E1 circuit type */
 144   lmc_ssi_watchdog
 145 };
 146
 147 lmc_media_t lmc_t1_media = {
 148   lmc_t1_init,                  /* special media init stuff */
 149   lmc_t1_default,               /* reset to default state */
 150   lmc_t1_set_status,            /* reset status to state provided */
 151   lmc_t1_set_clock,             /* set clock source */
 152   lmc_dummy_set2_1,             /* set line speed */
 153   lmc_dummy_set_1,              /* set cable length */
 154   lmc_dummy_set_1,              /* set scrambler */
 155   lmc_t1_get_link_status,       /* get link status */
 156   lmc_dummy_set_1,              /* set link status */
 157   lmc_t1_set_crc_length,        /* set CRC length */
 158   lmc_t1_set_circuit_type,      /* set T1 or E1 circuit type */
 159   lmc_t1_watchdog
 160 };
 161
 162 static void
 163 lmc_dummy_set_1 (lmc_softc_t * const sc, int a)
 164 {
 165 }
 166
 167 static void
 168 lmc_dummy_set2_1 (lmc_softc_t * const sc, lmc_ctl_t * a)
 169 {
 170 }
 171
 172 /*
 173  *  HSSI methods
 174  */
 175
 176 static void
 177 lmc_hssi_init (lmc_softc_t * const sc)
 178 {
 179   sc->ictl.cardtype = LMC_CTL_CARDTYPE_LMC5200;
 180
 181   lmc_gpio_mkoutput (sc, LMC_GEP_HSSI_CLOCK);
 182 }
 183
 184 static void
 185 lmc_hssi_default (lmc_softc_t * const sc)
 186 {
 187   sc->lmc_miireg16 = LMC_MII16_LED_ALL;
 188
 189   sc->lmc_media->set_link_status (sc, LMC_LINK_DOWN);
 190   sc->lmc_media->set_clock_source (sc, LMC_CTL_CLOCK_SOURCE_EXT);
 191   sc->lmc_media->set_crc_length (sc, LMC_CTL_CRC_LENGTH_16);
 192 }
 193
 194 /*
 195  * Given a user provided state, set ourselves up to match it.  This will
 196  * always reset the card if needed.
 197  */
 198 static void
 199 lmc_hssi_set_status (lmc_softc_t * const sc, lmc_ctl_t * ctl)
 200 {
 201   if (ctl == NULL)
 202     {
 203       sc->lmc_media->set_clock_source (sc, sc->ictl.clock_source);
 204       lmc_set_protocol (sc, NULL);
 205
 206       return;
 207     }
 208
 209   /*
 210    * check for change in clock source
 211    */
 212   if (ctl->clock_source && !sc->ictl.clock_source)
 213     {
 214       sc->lmc_media->set_clock_source (sc, LMC_CTL_CLOCK_SOURCE_INT);
 215       sc->lmc_timing = LMC_CTL_CLOCK_SOURCE_INT;
 216     }
 217   else if (!ctl->clock_source && sc->ictl.clock_source)
 218     {
 219       sc->lmc_timing = LMC_CTL_CLOCK_SOURCE_EXT;
 220       sc->lmc_media->set_clock_source (sc, LMC_CTL_CLOCK_SOURCE_EXT);
 221     }
 222
 223   lmc_set_protocol (sc, ctl);
 224 }
 225
 226 /*
 227  * 1 == internal, 0 == external
 228  */
 229 static void
 230 lmc_hssi_set_clock (lmc_softc_t * const sc, int ie)
 231 {
 232   int old;
 233   old = sc->ictl.clock_source;
 234   if (ie == LMC_CTL_CLOCK_SOURCE_EXT)
 235     {
 236       sc->lmc_gpio |= LMC_GEP_HSSI_CLOCK;
 237       LMC_CSR_WRITE (sc, csr_gp, sc->lmc_gpio);
 238       sc->ictl.clock_source = LMC_CTL_CLOCK_SOURCE_EXT;
 239       if(old != ie)
 240         printk (LMC_PRINTF_FMT ": clock external\n", LMC_PRINTF_ARGS);
 241     }
 242   else
 243     {
 244       sc->lmc_gpio &= ~(LMC_GEP_HSSI_CLOCK);
 245       LMC_CSR_WRITE (sc, csr_gp, sc->lmc_gpio);
 246       sc->ictl.clock_source = LMC_CTL_CLOCK_SOURCE_INT;
 247       if(old != ie)
 248         printk (LMC_PRINTF_FMT ": clock internal\n", LMC_PRINTF_ARGS);
 249     }
 250 }
 251
 252 /*
 253  * return hardware link status.
 254  * 0 == link is down, 1 == link is up.
 255  */
 256 static int
 257 lmc_hssi_get_link_status (lmc_softc_t * const sc)
 258 {
 259     /*
 260      * We're using the same code as SSI since
 261      * they're practically the same
 262      */
 263     return lmc_ssi_get_link_status(sc);
 264 }
 265
 266 static void
 267 lmc_hssi_set_link_status (lmc_softc_t * const sc, int state)
 268 {
 269   if (state == LMC_LINK_UP)
 270     sc->lmc_miireg16 |= LMC_MII16_HSSI_TA;
 271   else
 272     sc->lmc_miireg16 &= ~LMC_MII16_HSSI_TA;
 273
 274   lmc_mii_writereg (sc, 0, 16, sc->lmc_miireg16);
 275 }
 276
 277 /*
 278  * 0 == 16bit, 1 == 32bit
 279  */
 280 static void
 281 lmc_hssi_set_crc_length (lmc_softc_t * const sc, int state)
 282 {
 283   if (state == LMC_CTL_CRC_LENGTH_32)
 284     {
 285       /* 32 bit */
 286       sc->lmc_miireg16 |= LMC_MII16_HSSI_CRC;
 287       sc->ictl.crc_length = LMC_CTL_CRC_LENGTH_32;
 288     }
 289   else
 290     {
 291       /* 16 bit */
 292       sc->lmc_miireg16 &= ~LMC_MII16_HSSI_CRC;
 293       sc->ictl.crc_length = LMC_CTL_CRC_LENGTH_16;
 294     }
 295
 296   lmc_mii_writereg (sc, 0, 16, sc->lmc_miireg16);
 297 }
 298
 299 static void
 300 lmc_hssi_watchdog (lmc_softc_t * const sc)
 301 {
 302   /* HSSI is blank */
 303 }
 304
 305 /*
 306  *  DS3 methods
 307  */
 308
 309 /*
 310  * Set cable length
 311  */
 312 static void
 313 lmc_ds3_set_100ft (lmc_softc_t * const sc, int ie)
 314 {
 315   if (ie == LMC_CTL_CABLE_LENGTH_GT_100FT)
 316     {
 317       sc->lmc_miireg16 &= ~LMC_MII16_DS3_ZERO;
 318       sc->ictl.cable_length = LMC_CTL_CABLE_LENGTH_GT_100FT;
 319     }
 320   else if (ie == LMC_CTL_CABLE_LENGTH_LT_100FT)
 321     {
 322       sc->lmc_miireg16 |= LMC_MII16_DS3_ZERO;
 323       sc->ictl.cable_length = LMC_CTL_CABLE_LENGTH_LT_100FT;
 324     }
 325   lmc_mii_writereg (sc, 0, 16, sc->lmc_miireg16);
 326 }
 327
 328 static void
 329 lmc_ds3_default (lmc_softc_t * const sc)
 330 {
 331   sc->lmc_miireg16 = LMC_MII16_LED_ALL;
 332
 333   sc->lmc_media->set_link_status (sc, LMC_LINK_DOWN);
 334   sc->lmc_media->set_cable_length (sc, LMC_CTL_CABLE_LENGTH_LT_100FT);
 335   sc->lmc_media->set_scrambler (sc, LMC_CTL_OFF);
 336   sc->lmc_media->set_crc_length (sc, LMC_CTL_CRC_LENGTH_16);
 337 }
 338
 339 /*
 340  * Given a user provided state, set ourselves up to match it.  This will
 341  * always reset the card if needed.
 342  */
 343 static void
 344 lmc_ds3_set_status (lmc_softc_t * const sc, lmc_ctl_t * ctl)
 345 {
 346   if (ctl == NULL)
 347     {
 348       sc->lmc_media->set_cable_length (sc, sc->ictl.cable_length);
 349       sc->lmc_media->set_scrambler (sc, sc->ictl.scrambler_onoff);
 350       lmc_set_protocol (sc, NULL);
 351
 352       return;
 353     }
 354
 355   /*
 356    * check for change in cable length setting
 357    */
 358   if (ctl->cable_length && !sc->ictl.cable_length)
 359     lmc_ds3_set_100ft (sc, LMC_CTL_CABLE_LENGTH_GT_100FT);
 360   else if (!ctl->cable_length && sc->ictl.cable_length)
 361     lmc_ds3_set_100ft (sc, LMC_CTL_CABLE_LENGTH_LT_100FT);
 362
 363   /*
 364    * Check for change in scrambler setting (requires reset)
 365    */
 366   if (ctl->scrambler_onoff && !sc->ictl.scrambler_onoff)
 367     lmc_ds3_set_scram (sc, LMC_CTL_ON);
 368   else if (!ctl->scrambler_onoff && sc->ictl.scrambler_onoff)
 369     lmc_ds3_set_scram (sc, LMC_CTL_OFF);
 370
 371   lmc_set_protocol (sc, ctl);
 372 }
 373
 374 static void
 375 lmc_ds3_init (lmc_softc_t * const sc)
 376 {
 377   int i;
 378
 379   sc->ictl.cardtype = LMC_CTL_CARDTYPE_LMC5245;
 380
 381   /* writes zeros everywhere */
 382   for (i = 0; i < 21; i++)
 383     {
 384       lmc_mii_writereg (sc, 0, 17, i);
 385       lmc_mii_writereg (sc, 0, 18, 0);
 386     }
 387
 388   /* set some essential bits */
 389   lmc_mii_writereg (sc, 0, 17, 1);
 390   lmc_mii_writereg (sc, 0, 18, 0x25);   /* ser, xtx */
 391
 392   lmc_mii_writereg (sc, 0, 17, 5);
 393   lmc_mii_writereg (sc, 0, 18, 0x80);   /* emode */
 394
 395   lmc_mii_writereg (sc, 0, 17, 14);
 396   lmc_mii_writereg (sc, 0, 18, 0x30);   /* rcgen, tcgen */
 397
 398   /* clear counters and latched bits */
 399   for (i = 0; i < 21; i++)
 400     {
 401       lmc_mii_writereg (sc, 0, 17, i);
 402       lmc_mii_readreg (sc, 0, 18);
 403     }
 404 }
 405
 406 /*
 407  * 1 == DS3 payload scrambled, 0 == not scrambled
 408  */
 409 static void
 410 lmc_ds3_set_scram (lmc_softc_t * const sc, int ie)
 411 {
 412   if (ie == LMC_CTL_ON)
 413     {
 414       sc->lmc_miireg16 |= LMC_MII16_DS3_SCRAM;
 415       sc->ictl.scrambler_onoff = LMC_CTL_ON;
 416     }
 417   else
 418     {
 419       sc->lmc_miireg16 &= ~LMC_MII16_DS3_SCRAM;
 420       sc->ictl.scrambler_onoff = LMC_CTL_OFF;
 421     }
 422   lmc_mii_writereg (sc, 0, 16, sc->lmc_miireg16);
 423 }
 424
 425 /*
 426  * return hardware link status.
 427  * 0 == link is down, 1 == link is up.
 428  */
 429 static int
 430 lmc_ds3_get_link_status (lmc_softc_t * const sc)
 431 {
 432     u_int16_t link_status, link_status_11;
 433     int ret = 1;
 434
 435     lmc_mii_writereg (sc, 0, 17, 7);
 436     link_status = lmc_mii_readreg (sc, 0, 18);
 437
 438     /* LMC5245 (DS3) & LMC1200 (DS1) LED definitions
 439      * led0 yellow = far-end adapter is in Red alarm condition
 440      * led1 blue   = received an Alarm Indication signal
 441      *               (upstream failure)
 442      * led2 Green  = power to adapter, Gate Array loaded & driver
 443      *               attached
 444      * led3 red    = Loss of Signal (LOS) or out of frame (OOF)
 445      *               conditions detected on T3 receive signal
 446      */
 447
 448     lmc_led_on(sc, LMC_DS3_LED2);
 449
 450     if ((link_status & LMC_FRAMER_REG0_DLOS) ||
 451         (link_status & LMC_FRAMER_REG0_OOFS)){
 452         ret = 0;
 453         if(sc->last_led_err[3] != 1){
 454             u16 r1;
 455             lmc_mii_writereg (sc, 0, 17, 01); /* Turn on Xbit error as our cisco does */
 456             r1 = lmc_mii_readreg (sc, 0, 18);
 457             r1 &= 0xfe;
 458             lmc_mii_writereg(sc, 0, 18, r1);
 459             printk(KERN_WARNING "%s: Red Alarm - Loss of Signal or Loss of Framing\n", sc->name);
 460         }
 461         lmc_led_on(sc, LMC_DS3_LED3);   /* turn on red LED */
 462         sc->last_led_err[3] = 1;
 463     }
 464     else {
 465         lmc_led_off(sc, LMC_DS3_LED3);  /* turn on red LED */
 466         if(sc->last_led_err[3] == 1){
 467             u16 r1;
 468             lmc_mii_writereg (sc, 0, 17, 01); /* Turn off Xbit error */
 469             r1 = lmc_mii_readreg (sc, 0, 18);
 470             r1 |= 0x01;
 471             lmc_mii_writereg(sc, 0, 18, r1);
 472         }
 473         sc->last_led_err[3] = 0;
 474     }
 475
 476     lmc_mii_writereg(sc, 0, 17, 0x10);
 477     link_status_11 = lmc_mii_readreg(sc, 0, 18);
 478     if((link_status & LMC_FRAMER_REG0_AIS) ||
 479        (link_status_11 & LMC_FRAMER_REG10_XBIT)) {
 480         ret = 0;
 481         if(sc->last_led_err[0] != 1){
 482             printk(KERN_WARNING "%s: AIS Alarm or XBit Error\n", sc->name);
 483             printk(KERN_WARNING "%s: Remote end has loss of signal or framing\n", sc->name);
 484         }
 485         lmc_led_on(sc, LMC_DS3_LED0);
 486         sc->last_led_err[0] = 1;
 487     }
 488     else {
 489         lmc_led_off(sc, LMC_DS3_LED0);
 490         sc->last_led_err[0] = 0;
 491     }
 492
 493     lmc_mii_writereg (sc, 0, 17, 9);
 494     link_status = lmc_mii_readreg (sc, 0, 18);
 495
 496     if(link_status & LMC_FRAMER_REG9_RBLUE){
 497         ret = 0;
 498         if(sc->last_led_err[1] != 1){
 499             printk(KERN_WARNING "%s: Blue Alarm - Receiving all 1's\n", sc->name);
 500         }
 501         lmc_led_on(sc, LMC_DS3_LED1);
 502         sc->last_led_err[1] = 1;
 503     }
 504     else {
 505         lmc_led_off(sc, LMC_DS3_LED1);
 506         sc->last_led_err[1] = 0;
 507     }
 508
 509     return ret;
 510 }
 511
 512 /*
 513  * 0 == 16bit, 1 == 32bit
 514  */
 515 static void
 516 lmc_ds3_set_crc_length (lmc_softc_t * const sc, int state)
 517 {
 518   if (state == LMC_CTL_CRC_LENGTH_32)
 519     {
 520       /* 32 bit */
 521       sc->lmc_miireg16 |= LMC_MII16_DS3_CRC;
 522       sc->ictl.crc_length = LMC_CTL_CRC_LENGTH_32;
 523     }
 524   else
 525     {
 526       /* 16 bit */
 527       sc->lmc_miireg16 &= ~LMC_MII16_DS3_CRC;
 528       sc->ictl.crc_length = LMC_CTL_CRC_LENGTH_16;
 529     }
 530
 531   lmc_mii_writereg (sc, 0, 16, sc->lmc_miireg16);
 532 }
 533
 534 static void
 535 lmc_ds3_watchdog (lmc_softc_t * const sc)
 536 {
 537
 538 }
 539
 540
 541 /*
 542  *  SSI methods
 543  */
 544
 545 static void
 546 lmc_ssi_init (lmc_softc_t * const sc)
 547 {
 548   u_int16_t mii17;
 549   int cable;
 550
 551   sc->ictl.cardtype = LMC_CTL_CARDTYPE_LMC1000;
 552
 553   mii17 = lmc_mii_readreg (sc, 0, 17);
 554
 555   cable = (mii17 & LMC_MII17_SSI_CABLE_MASK) >> LMC_MII17_SSI_CABLE_SHIFT;
 556   sc->ictl.cable_type = cable;
 557
 558   lmc_gpio_mkoutput (sc, LMC_GEP_SSI_TXCLOCK);
 559 }
 560
 561 static void
 562 lmc_ssi_default (lmc_softc_t * const sc)
 563 {
 564   sc->lmc_miireg16 = LMC_MII16_LED_ALL;
 565
 566   /*
 567    * make TXCLOCK always be an output
 568    */
 569   lmc_gpio_mkoutput (sc, LMC_GEP_SSI_TXCLOCK);
 570
 571   sc->lmc_media->set_link_status (sc, LMC_LINK_DOWN);
 572   sc->lmc_media->set_clock_source (sc, LMC_CTL_CLOCK_SOURCE_EXT);
 573   sc->lmc_media->set_speed (sc, NULL);
 574   sc->lmc_media->set_crc_length (sc, LMC_CTL_CRC_LENGTH_16);
 575 }
 576
 577 /*
 578  * Given a user provided state, set ourselves up to match it.  This will
 579  * always reset the card if needed.
 580  */
 581 static void
 582 lmc_ssi_set_status (lmc_softc_t * const sc, lmc_ctl_t * ctl)
 583 {
 584   if (ctl == NULL)
 585     {
 586       sc->lmc_media->set_clock_source (sc, sc->ictl.clock_source);
 587       sc->lmc_media->set_speed (sc, &sc->ictl);
 588       lmc_set_protocol (sc, NULL);
 589
 590       return;
 591     }
 592
 593   /*
 594    * check for change in clock source
 595    */
 596   if (ctl->clock_source == LMC_CTL_CLOCK_SOURCE_INT
 597       && sc->ictl.clock_source == LMC_CTL_CLOCK_SOURCE_EXT)
 598     {
 599       sc->lmc_media->set_clock_source (sc, LMC_CTL_CLOCK_SOURCE_INT);
 600       sc->lmc_timing = LMC_CTL_CLOCK_SOURCE_INT;
 601     }
 602   else if (ctl->clock_source == LMC_CTL_CLOCK_SOURCE_EXT
 603            && sc->ictl.clock_source == LMC_CTL_CLOCK_SOURCE_INT)
 604     {
 605       sc->lmc_media->set_clock_source (sc, LMC_CTL_CLOCK_SOURCE_EXT);
 606       sc->lmc_timing = LMC_CTL_CLOCK_SOURCE_EXT;
 607     }
 608
 609   if (ctl->clock_rate != sc->ictl.clock_rate)
 610     sc->lmc_media->set_speed (sc, ctl);
 611
 612   lmc_set_protocol (sc, ctl);
 613 }
 614
 615 /*
 616  * 1 == internal, 0 == external
 617  */
 618 static void
 619 lmc_ssi_set_clock (lmc_softc_t * const sc, int ie)
 620 {
 621   int old;
 622   old = ie;
 623   if (ie == LMC_CTL_CLOCK_SOURCE_EXT)
 624     {
 625       sc->lmc_gpio &= ~(LMC_GEP_SSI_TXCLOCK);
 626       LMC_CSR_WRITE (sc, csr_gp, sc->lmc_gpio);
 627       sc->ictl.clock_source = LMC_CTL_CLOCK_SOURCE_EXT;
 628       if(ie != old)
 629         printk (LMC_PRINTF_FMT ": clock external\n", LMC_PRINTF_ARGS);
 630     }
 631   else
 632     {
 633       sc->lmc_gpio |= LMC_GEP_SSI_TXCLOCK;
 634       LMC_CSR_WRITE (sc, csr_gp, sc->lmc_gpio);
 635       sc->ictl.clock_source = LMC_CTL_CLOCK_SOURCE_INT;
 636       if(ie != old)
 637         printk (LMC_PRINTF_FMT ": clock internal\n", LMC_PRINTF_ARGS);
 638     }
 639 }
 640
 641 static void
 642 lmc_ssi_set_speed (lmc_softc_t * const sc, lmc_ctl_t * ctl)
 643 {
 644   lmc_ctl_t *ictl = &sc->ictl;
 645   lmc_av9110_t *av;
 646
 647   /* original settings for clock rate of:
 648    *  100 Khz (8,25,0,0,2) were incorrect
 649    *  they should have been 80,125,1,3,3
 650    *  There are 17 param combinations to produce this freq.
 651    *  For 1.5 Mhz use 120,100,1,1,2 (226 param. combinations)
 652    */
 653   if (ctl == NULL)
 654     {
 655       av = &ictl->cardspec.ssi;
 656       ictl->clock_rate = 1500000;
 657       av->f = ictl->clock_rate;
 658       av->n = 120;
 659       av->m = 100;
 660       av->v = 1;
 661       av->x = 1;
 662       av->r = 2;
 663
 664       write_av9110 (sc, av->n, av->m, av->v, av->x, av->r);
 665       return;
 666     }
 667
 668   av = &ctl->cardspec.ssi;
 669
 670   if (av->f == 0)
 671     return;
 672
 673   ictl->clock_rate = av->f;     /* really, this is the rate we are */
 674   ictl->cardspec.ssi = *av;
 675
 676   write_av9110 (sc, av->n, av->m, av->v, av->x, av->r);
 677 }
 678
 679 /*
 680  * return hardware link status.
 681  * 0 == link is down, 1 == link is up.
 682  */
 683 static int
 684 lmc_ssi_get_link_status (lmc_softc_t * const sc)
 685 {
 686   u_int16_t link_status;
 687   u_int32_t ticks;
 688   int ret = 1;
 689   int hw_hdsk = 1;
 690
 691   /*
 692    * missing CTS?  Hmm.  If we require CTS on, we may never get the
 693    * link to come up, so omit it in this test.
 694    *
 695    * Also, it seems that with a loopback cable, DCD isn't asserted,
 696    * so just check for things like this:
 697    *      DSR _must_ be asserted.
 698    *      One of DCD or CTS must be asserted.
 699    */
 700
 701   /* LMC 1000 (SSI) LED definitions
 702    * led0 Green = power to adapter, Gate Array loaded &
 703    *              driver attached
 704    * led1 Green = DSR and DTR and RTS and CTS are set
 705    * led2 Green = Cable detected
 706    * led3 red   = No timing is available from the
 707    *              cable or the on-board frequency
 708    *              generator.
 709    */
 710
 711   link_status = lmc_mii_readreg (sc, 0, 16);
 712
 713   /* Is the transmit clock still available */
 714   ticks = LMC_CSR_READ (sc, csr_gp_timer);
 715   ticks = 0x0000ffff - (ticks & 0x0000ffff);
 716
 717   lmc_led_on (sc, LMC_MII16_LED0);
 718
 719   /* ====== transmit clock determination ===== */
 720   if (sc->lmc_timing == LMC_CTL_CLOCK_SOURCE_INT) {
 721       lmc_led_off(sc, LMC_MII16_LED3);
 722   }
 723   else if (ticks == 0 ) {                               /* no clock found ? */
 724       ret = 0;
 725       if(sc->last_led_err[3] != 1){
 726           sc->stats.tx_lossOfClockCnt++;
 727           printk(KERN_WARNING "%s: Lost Clock, Link Down\n", sc->name);
 728       }
 729       sc->last_led_err[3] = 1;
 730       lmc_led_on (sc, LMC_MII16_LED3);  /* turn ON red LED */
 731   }
 732   else {
 733       if(sc->last_led_err[3] == 1)
 734           printk(KERN_WARNING "%s: Clock Returned\n", sc->name);
 735       sc->last_led_err[3] = 0;
 736       lmc_led_off (sc, LMC_MII16_LED3);         /* turn OFF red LED */
 737   }
 738
 739   if ((link_status & LMC_MII16_SSI_DSR) == 0) { /* Also HSSI CA */
 740       ret = 0;
 741       hw_hdsk = 0;
 742   }
 743
 744 #ifdef CONFIG_LMC_IGNORE_HARDWARE_HANDSHAKE
 745   if ((link_status & (LMC_MII16_SSI_CTS | LMC_MII16_SSI_DCD)) == 0){
 746       ret = 0;
 747       hw_hdsk = 0;
 748   }
 749 #endif
 750
 751   if(hw_hdsk == 0){
 752       if(sc->last_led_err[1] != 1)
 753           printk(KERN_WARNING "%s: DSR not asserted\n", sc->name);
 754       sc->last_led_err[1] = 1;
 755       lmc_led_off(sc, LMC_MII16_LED1);
 756   }
 757   else {
 758       if(sc->last_led_err[1] != 0)
 759           printk(KERN_WARNING "%s: DSR now asserted\n", sc->name);
 760       sc->last_led_err[1] = 0;
 761       lmc_led_on(sc, LMC_MII16_LED1);
 762   }
 763
 764   if(ret == 1) {
 765       lmc_led_on(sc, LMC_MII16_LED2); /* Over all good status? */
 766   }
 767
 768   return ret;
 769 }
 770
 771 static void
 772 lmc_ssi_set_link_status (lmc_softc_t * const sc, int state)
 773 {
 774   if (state == LMC_LINK_UP)
 775     {
 776       sc->lmc_miireg16 |= (LMC_MII16_SSI_DTR | LMC_MII16_SSI_RTS);
 777       printk (LMC_PRINTF_FMT ": asserting DTR and RTS\n", LMC_PRINTF_ARGS);
 778     }
 779   else
 780     {
 781       sc->lmc_miireg16 &= ~(LMC_MII16_SSI_DTR | LMC_MII16_SSI_RTS);
 782       printk (LMC_PRINTF_FMT ": deasserting DTR and RTS\n", LMC_PRINTF_ARGS);
 783     }
 784
 785   lmc_mii_writereg (sc, 0, 16, sc->lmc_miireg16);
 786
 787 }
 788
 789 /*
 790  * 0 == 16bit, 1 == 32bit
 791  */
 792 static void
 793 lmc_ssi_set_crc_length (lmc_softc_t * const sc, int state)
 794 {
 795   if (state == LMC_CTL_CRC_LENGTH_32)
 796     {
 797       /* 32 bit */
 798       sc->lmc_miireg16 |= LMC_MII16_SSI_CRC;
 799       sc->ictl.crc_length = LMC_CTL_CRC_LENGTH_32;
 800       sc->lmc_crcSize = LMC_CTL_CRC_BYTESIZE_4;
 801
 802     }
 803   else
 804     {
 805       /* 16 bit */
 806       sc->lmc_miireg16 &= ~LMC_MII16_SSI_CRC;
 807       sc->ictl.crc_length = LMC_CTL_CRC_LENGTH_16;
 808       sc->lmc_crcSize = LMC_CTL_CRC_BYTESIZE_2;
 809     }
 810
 811   lmc_mii_writereg (sc, 0, 16, sc->lmc_miireg16);
 812 }
 813
 814 /*
 815  * These are bits to program the ssi frequency generator
 816  */
 817 static inline void
 818 write_av9110_bit (lmc_softc_t * sc, int c)
 819 {
 820   /*
 821    * set the data bit as we need it.
 822    */
 823   sc->lmc_gpio &= ~(LMC_GEP_CLK);
 824   if (c & 0x01)
 825     sc->lmc_gpio |= LMC_GEP_DATA;
 826   else
 827     sc->lmc_gpio &= ~(LMC_GEP_DATA);
 828   LMC_CSR_WRITE (sc, csr_gp, sc->lmc_gpio);
 829
 830   /*
 831    * set the clock to high
 832    */
 833   sc->lmc_gpio |= LMC_GEP_CLK;
 834   LMC_CSR_WRITE (sc, csr_gp, sc->lmc_gpio);
 835
 836   /*
 837    * set the clock to low again.
 838    */
 839   sc->lmc_gpio &= ~(LMC_GEP_CLK);
 840   LMC_CSR_WRITE (sc, csr_gp, sc->lmc_gpio);
 841 }
 842
 843 static void
 844 write_av9110 (lmc_softc_t * sc, u_int32_t n, u_int32_t m, u_int32_t v,
 845               u_int32_t x, u_int32_t r)
 846 {
 847   int i;
 848
 849 #if 0
 850   printk (LMC_PRINTF_FMT ": speed %u, %d %d %d %d %d\n",
 851           LMC_PRINTF_ARGS, sc->ictl.clock_rate, n, m, v, x, r);
 852 #endif
 853
 854   sc->lmc_gpio |= LMC_GEP_SSI_GENERATOR;
 855   sc->lmc_gpio &= ~(LMC_GEP_DATA | LMC_GEP_CLK);
 856   LMC_CSR_WRITE (sc, csr_gp, sc->lmc_gpio);
 857
 858   /*
 859    * Set the TXCLOCK, GENERATOR, SERIAL, and SERIALCLK
 860    * as outputs.
 861    */
 862   lmc_gpio_mkoutput (sc, (LMC_GEP_DATA | LMC_GEP_CLK
 863                           | LMC_GEP_SSI_GENERATOR));
 864
 865   sc->lmc_gpio &= ~(LMC_GEP_SSI_GENERATOR);
 866   LMC_CSR_WRITE (sc, csr_gp, sc->lmc_gpio);
 867
 868   /*
 869    * a shifting we will go...
 870    */
 871   for (i = 0; i < 7; i++)
 872     write_av9110_bit (sc, n >> i);
 873   for (i = 0; i < 7; i++)
 874     write_av9110_bit (sc, m >> i);
 875   for (i = 0; i < 1; i++)
 876     write_av9110_bit (sc, v >> i);
 877   for (i = 0; i < 2; i++)
 878     write_av9110_bit (sc, x >> i);
 879   for (i = 0; i < 2; i++)
 880     write_av9110_bit (sc, r >> i);
 881   for (i = 0; i < 5; i++)
 882     write_av9110_bit (sc, 0x17 >> i);
 883
 884   /*
 885    * stop driving serial-related signals
 886    */
 887   lmc_gpio_mkinput (sc,
 888                     (LMC_GEP_DATA | LMC_GEP_CLK
 889                      | LMC_GEP_SSI_GENERATOR));
 890 }
 891
 892 static void
 893 lmc_ssi_watchdog (lmc_softc_t * const sc)
 894 {
 895   u_int16_t mii17;
 896   struct ssicsr2
 897   {
 898     unsigned short dtr:1, dsr:1, rts:1, cable:3, crc:1, led0:1, led1:1,
 899       led2:1, led3:1, fifo:1, ll:1, rl:1, tm:1, loop:1;
 900   };
 901   struct ssicsr2 *ssicsr;
 902   mii17 = lmc_mii_readreg (sc, 0, 17);
 903   ssicsr = (struct ssicsr2 *) &mii17;
 904   if (ssicsr->cable == 7)
 905     {
 906       lmc_led_off (sc, LMC_MII16_LED2);
 907     }
 908   else
 909     {
 910       lmc_led_on (sc, LMC_MII16_LED2);
 911     }
 912
 913 }
 914
 915 /*
 916  *  T1 methods
 917  */
 918
 919 /*
 920  * The framer regs are multiplexed through MII regs 17 & 18
 921  *  write the register address to MII reg 17 and the *  data to MII reg 18. */
 922 static void
 923 lmc_t1_write (lmc_softc_t * const sc, int a, int d)
 924 {
 925   lmc_mii_writereg (sc, 0, 17, a);
 926   lmc_mii_writereg (sc, 0, 18, d);
 927 }
 928
 929 /* Save a warning
 930 static int
 931 lmc_t1_read (lmc_softc_t * const sc, int a)
 932 {
 933   lmc_mii_writereg (sc, 0, 17, a);
 934   return lmc_mii_readreg (sc, 0, 18);
 935 }
 936 */
 937
 938
 939 static void
 940 lmc_t1_init (lmc_softc_t * const sc)
 941 {
 942   u_int16_t mii16;
 943   int i;
 944
 945   sc->ictl.cardtype = LMC_CTL_CARDTYPE_LMC1200;
 946   mii16 = lmc_mii_readreg (sc, 0, 16);
 947
 948   /* reset 8370 */
 949   mii16 &= ~LMC_MII16_T1_RST;
 950   lmc_mii_writereg (sc, 0, 16, mii16 | LMC_MII16_T1_RST);
 951   lmc_mii_writereg (sc, 0, 16, mii16);
 952
 953   /* set T1 or E1 line.  Uses sc->lmcmii16 reg in function so update it */
 954   sc->lmc_miireg16 = mii16;
 955   lmc_t1_set_circuit_type(sc, LMC_CTL_CIRCUIT_TYPE_T1);
 956   mii16 = sc->lmc_miireg16;
 957
 958   lmc_t1_write (sc, 0x01, 0x1B);        /* CR0     - primary control             */
 959   lmc_t1_write (sc, 0x02, 0x42);        /* JAT_CR  - jitter atten config         */
 960   lmc_t1_write (sc, 0x14, 0x00);        /* LOOP    - loopback config             */
 961   lmc_t1_write (sc, 0x15, 0x00);        /* DL3_TS  - external data link timeslot */
 962   lmc_t1_write (sc, 0x18, 0xFF);        /* PIO     - programmable I/O            */
 963   lmc_t1_write (sc, 0x19, 0x30);        /* POE     - programmable OE             */
 964   lmc_t1_write (sc, 0x1A, 0x0F);        /* CMUX    - clock input mux             */
 965   lmc_t1_write (sc, 0x20, 0x41);        /* LIU_CR  - RX LIU config               */
 966   lmc_t1_write (sc, 0x22, 0x76);        /* RLIU_CR - RX LIU config               */
 967   lmc_t1_write (sc, 0x40, 0x03);        /* RCR0    - RX config                   */
 968   lmc_t1_write (sc, 0x45, 0x00);        /* RALM    - RX alarm config             */
 969   lmc_t1_write (sc, 0x46, 0x05);        /* LATCH   - RX alarm/err/cntr latch     */
 970   lmc_t1_write (sc, 0x68, 0x40);        /* TLIU_CR - TX LIU config               */
 971   lmc_t1_write (sc, 0x70, 0x0D);        /* TCR0    - TX framer config            */
 972   lmc_t1_write (sc, 0x71, 0x05);        /* TCR1    - TX config                   */
 973   lmc_t1_write (sc, 0x72, 0x0B);        /* TFRM    - TX frame format             */
 974   lmc_t1_write (sc, 0x73, 0x00);        /* TERROR  - TX error insert             */
 975   lmc_t1_write (sc, 0x74, 0x00);        /* TMAN    - TX manual Sa/FEBE config    */
 976   lmc_t1_write (sc, 0x75, 0x00);        /* TALM    - TX alarm signal config      */
 977   lmc_t1_write (sc, 0x76, 0x00);        /* TPATT   - TX test pattern config      */
 978   lmc_t1_write (sc, 0x77, 0x00);        /* TLB     - TX inband loopback config   */
 979   lmc_t1_write (sc, 0x90, 0x05);        /* CLAD_CR - clock rate adapter config   */
 980   lmc_t1_write (sc, 0x91, 0x05);        /* CSEL    - clad freq sel               */
 981   lmc_t1_write (sc, 0xA6, 0x00);        /* DL1_CTL - DL1 control                 */
 982   lmc_t1_write (sc, 0xB1, 0x00);        /* DL2_CTL - DL2 control                 */
 983   lmc_t1_write (sc, 0xD0, 0x47);        /* SBI_CR  - sys bus iface config        */
 984   lmc_t1_write (sc, 0xD1, 0x70);        /* RSB_CR  - RX sys bus config           */
 985   lmc_t1_write (sc, 0xD4, 0x30);        /* TSB_CR  - TX sys bus config           */
 986   for (i = 0; i < 32; i++)
 987     {
 988       lmc_t1_write (sc, 0x0E0 + i, 0x00);       /* SBCn - sys bus per-channel ctl    */
 989       lmc_t1_write (sc, 0x100 + i, 0x00);       /* TPCn - TX per-channel ctl         */
 990       lmc_t1_write (sc, 0x180 + i, 0x00);       /* RPCn - RX per-channel ctl         */
 991     }
 992   for (i = 1; i < 25; i++)
 993     {
 994       lmc_t1_write (sc, 0x0E0 + i, 0x0D);       /* SBCn - sys bus per-channel ctl    */
 995     }
 996
 997   mii16 |= LMC_MII16_T1_XOE;
 998   lmc_mii_writereg (sc, 0, 16, mii16);
 999   sc->lmc_miireg16 = mii16;
1000 }
1001
1002 static void
1003 lmc_t1_default (lmc_softc_t * const sc)
1004 {
1005   sc->lmc_miireg16 = LMC_MII16_LED_ALL;
1006   sc->lmc_media->set_link_status (sc, LMC_LINK_DOWN);
1007   sc->lmc_media->set_circuit_type (sc, LMC_CTL_CIRCUIT_TYPE_T1);
1008   sc->lmc_media->set_crc_length (sc, LMC_CTL_CRC_LENGTH_16);
1009   /* Right now we can only clock from out internal source */
1010   sc->ictl.clock_source = LMC_CTL_CLOCK_SOURCE_INT;
1011 }
1012 /* * Given a user provided state, set ourselves up to match it.  This will * always reset the card if needed.
1013  */
1014 static void
1015 lmc_t1_set_status (lmc_softc_t * const sc, lmc_ctl_t * ctl)
1016 {
1017   if (ctl == NULL)
1018     {
1019       sc->lmc_media->set_circuit_type (sc, sc->ictl.circuit_type);
1020       lmc_set_protocol (sc, NULL);
1021
1022       return;
1023     }
1024   /*
1025    * check for change in circuit type         */
1026   if (ctl->circuit_type == LMC_CTL_CIRCUIT_TYPE_T1
1027       && sc->ictl.circuit_type ==
1028       LMC_CTL_CIRCUIT_TYPE_E1) sc->lmc_media->set_circuit_type (sc,
1029                                                                 LMC_CTL_CIRCUIT_TYPE_E1);
1030   else if (ctl->circuit_type == LMC_CTL_CIRCUIT_TYPE_E1
1031            && sc->ictl.circuit_type == LMC_CTL_CIRCUIT_TYPE_T1)
1032     sc->lmc_media->set_circuit_type (sc, LMC_CTL_CIRCUIT_TYPE_T1);
1033   lmc_set_protocol (sc, ctl);
1034 }
1035 /*
1036  * return hardware link status.
1037  * 0 == link is down, 1 == link is up.
1038  */ static int
1039 lmc_t1_get_link_status (lmc_softc_t * const sc)
1040 {
1041     u_int16_t link_status;
1042     int ret = 1;
1043
1044   /* LMC5245 (DS3) & LMC1200 (DS1) LED definitions
1045    * led0 yellow = far-end adapter is in Red alarm condition
1046    * led1 blue   = received an Alarm Indication signal
1047    *               (upstream failure)
1048    * led2 Green  = power to adapter, Gate Array loaded & driver
1049    *               attached
1050    * led3 red    = Loss of Signal (LOS) or out of frame (OOF)
1051    *               conditions detected on T3 receive signal
1052    */
1053     lmc_trace(sc->lmc_device, "lmc_t1_get_link_status in");
1054     lmc_led_on(sc, LMC_DS3_LED2);
1055
1056     lmc_mii_writereg (sc, 0, 17, T1FRAMER_ALARM1_STATUS);
1057     link_status = lmc_mii_readreg (sc, 0, 18);
1058
1059
1060     if (link_status & T1F_RAIS) {                       /* turn on blue LED */
1061         ret = 0;
1062         if(sc->last_led_err[1] != 1){
1063             printk(KERN_WARNING "%s: Receive AIS/Blue Alarm. Far end in RED alarm\n", sc->name);
1064         }
1065         lmc_led_on(sc, LMC_DS3_LED1);
1066         sc->last_led_err[1] = 1;
1067     }
1068     else {
1069         if(sc->last_led_err[1] != 0){
1070             printk(KERN_WARNING "%s: End AIS/Blue Alarm\n", sc->name);
1071         }
1072         lmc_led_off (sc, LMC_DS3_LED1);
1073         sc->last_led_err[1] = 0;
1074     }
1075
1076     /*
1077      * Yellow Alarm is nasty evil stuff, looks at data patterns
1078      * inside the channel and confuses it with HDLC framing
1079      * ignore all yellow alarms.
1080      *
1081      * Do listen to MultiFrame Yellow alarm which while implemented
1082      * different ways isn't in the channel and hence somewhat
1083      * more reliable
1084      */
1085
1086     if (link_status & T1F_RMYEL) {
1087         ret = 0;
1088         if(sc->last_led_err[0] != 1){
1089             printk(KERN_WARNING "%s: Receive Yellow AIS Alarm\n", sc->name);
1090         }
1091         lmc_led_on(sc, LMC_DS3_LED0);
1092         sc->last_led_err[0] = 1;
1093     }
1094     else {
1095         if(sc->last_led_err[0] != 0){
1096             printk(KERN_WARNING "%s: End of Yellow AIS Alarm\n", sc->name);
1097         }
1098         lmc_led_off(sc, LMC_DS3_LED0);
1099         sc->last_led_err[0] = 0;
1100     }
1101
1102     /*
1103      * Loss of signal and los of frame
1104      * Use the green bit to identify which one lit the led
1105      */
1106     if(link_status & T1F_RLOF){
1107         ret = 0;
1108         if(sc->last_led_err[3] != 1){
1109             printk(KERN_WARNING "%s: Local Red Alarm: Loss of Framing\n", sc->name);
1110         }
1111         lmc_led_on(sc, LMC_DS3_LED3);
1112         sc->last_led_err[3] = 1;
1113
1114     }
1115     else {
1116         if(sc->last_led_err[3] != 0){
1117             printk(KERN_WARNING "%s: End Red Alarm (LOF)\n", sc->name);
1118         }
1119         if( ! (link_status & T1F_RLOS))
1120             lmc_led_off(sc, LMC_DS3_LED3);
1121         sc->last_led_err[3] = 0;
1122     }
1123
1124     if(link_status & T1F_RLOS){
1125         ret = 0;
1126         if(sc->last_led_err[2] != 1){
1127             printk(KERN_WARNING "%s: Local Red Alarm: Loss of Signal\n", sc->name);
1128         }
1129         lmc_led_on(sc, LMC_DS3_LED3);
1130         sc->last_led_err[2] = 1;
1131
1132     }
1133     else {
1134         if(sc->last_led_err[2] != 0){
1135             printk(KERN_WARNING "%s: End Red Alarm (LOS)\n", sc->name);
1136         }
1137         if( ! (link_status & T1F_RLOF))
1138             lmc_led_off(sc, LMC_DS3_LED3);
1139         sc->last_led_err[2] = 0;
1140     }
1141
1142     sc->lmc_xinfo.t1_alarm1_status = link_status;
1143
1144     lmc_mii_writereg (sc, 0, 17, T1FRAMER_ALARM2_STATUS);
1145     sc->lmc_xinfo.t1_alarm2_status = lmc_mii_readreg (sc, 0, 18);
1146
1147
1148     lmc_trace(sc->lmc_device, "lmc_t1_get_link_status out");
1149
1150     return ret;
1151 }
1152
1153 /*
1154  * 1 == T1 Circuit Type , 0 == E1 Circuit Type
1155  */
1156 static void
1157 lmc_t1_set_circuit_type (lmc_softc_t * const sc, int ie)
1158 {
1159   if (ie == LMC_CTL_CIRCUIT_TYPE_T1) {
1160       sc->lmc_miireg16 |= LMC_MII16_T1_Z;
1161       sc->ictl.circuit_type = LMC_CTL_CIRCUIT_TYPE_T1;
1162       printk(KERN_INFO "%s: In T1 Mode\n", sc->name);
1163   }
1164   else {
1165       sc->lmc_miireg16 &= ~LMC_MII16_T1_Z;
1166       sc->ictl.circuit_type = LMC_CTL_CIRCUIT_TYPE_E1;
1167       printk(KERN_INFO "%s: In E1 Mode\n", sc->name);
1168   }
1169
1170   lmc_mii_writereg (sc, 0, 16, sc->lmc_miireg16);
1171
1172 }
1173
1174 /*
1175  * 0 == 16bit, 1 == 32bit */
1176 static void
1177 lmc_t1_set_crc_length (lmc_softc_t * const sc, int state)
1178 {
1179   if (state == LMC_CTL_CRC_LENGTH_32)
1180     {
1181       /* 32 bit */
1182       sc->lmc_miireg16 |= LMC_MII16_T1_CRC;
1183       sc->ictl.crc_length = LMC_CTL_CRC_LENGTH_32;
1184       sc->lmc_crcSize = LMC_CTL_CRC_BYTESIZE_4;
1185
1186     }
1187   else
1188     {
1189       /* 16 bit */ sc->lmc_miireg16 &= ~LMC_MII16_T1_CRC;
1190       sc->ictl.crc_length = LMC_CTL_CRC_LENGTH_16;
1191       sc->lmc_crcSize = LMC_CTL_CRC_BYTESIZE_2;
1192
1193     }
1194
1195   lmc_mii_writereg (sc, 0, 16, sc->lmc_miireg16);
1196 }
1197
1198 /*
1199  * 1 == internal, 0 == external
1200  */
1201 static void
1202 lmc_t1_set_clock (lmc_softc_t * const sc, int ie)
1203 {
1204   int old;
1205   old = ie;
1206   if (ie == LMC_CTL_CLOCK_SOURCE_EXT)
1207     {
1208       sc->lmc_gpio &= ~(LMC_GEP_SSI_TXCLOCK);
1209       LMC_CSR_WRITE (sc, csr_gp, sc->lmc_gpio);
1210       sc->ictl.clock_source = LMC_CTL_CLOCK_SOURCE_EXT;
1211       if(old != ie)
1212         printk (LMC_PRINTF_FMT ": clock external\n", LMC_PRINTF_ARGS);
1213     }
1214   else
1215     {
1216       sc->lmc_gpio |= LMC_GEP_SSI_TXCLOCK;
1217       LMC_CSR_WRITE (sc, csr_gp, sc->lmc_gpio);
1218       sc->ictl.clock_source = LMC_CTL_CLOCK_SOURCE_INT;
1219       if(old != ie)
1220         printk (LMC_PRINTF_FMT ": clock internal\n", LMC_PRINTF_ARGS);
1221     }
1222 }
1223
1224 static void
1225 lmc_t1_watchdog (lmc_softc_t * const sc)
1226 {
1227 }
1228
1229 static void
1230 lmc_set_protocol (lmc_softc_t * const sc, lmc_ctl_t * ctl)
1231 {
1232   if (ctl == 0)
1233     {
1234       sc->ictl.keepalive_onoff = LMC_CTL_ON;
1235
1236       return;
1237     }
1238 }