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