740cc30a31efb74e56fe2a9bd8781b0f421e8e80
[people/xl0/gpxe.git] / src / drivers / net / via-velocity.c
1 /**************************************************************************
2 *    via-velocity.c: Etherboot device driver for the VIA 6120 Gigabit
3 *    Changes for Etherboot port:
4 *       Copyright (c) 2006 by Timothy Legge <tlegge@rogers.com>
5 *
6 *    This program is free software; you can redistribute it and/or modify
7 *    it under the terms of the GNU General Public License as published by
8 *    the Free Software Foundation; either version 2 of the License, or
9 *    (at your option) any later version.
10 *
11 *    This program is distributed in the hope that it will be useful,
12 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
13 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 *    GNU General Public License for more details.
15 *
16 *    You should have received a copy of the GNU General Public License
17 *    along with this program; if not, write to the Free Software
18 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 *
20 *    This driver is based on:
21 *         via-velocity.c: VIA Velocity VT6120, VT6122 Ethernet driver 
22 *             The changes are (c) Copyright 2004, Red Hat Inc. 
23 *                <alan@redhat.com>
24 *             Additional fixes and clean up: Francois Romieu
25 *
26 *     Original code:
27 *         Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
28 *         All rights reserved.
29 *             Author: Chuang Liang-Shing, AJ Jiang
30
31 *    Linux Driver Version 2.6.15.4
32
33 *    REVISION HISTORY:
34 *    ================
35 *
36 *    v1.0       03-06-2006      timlegge        Initial port of Linux driver
37 *    
38 *    Indent Options: indent -kr -i8
39 *************************************************************************/
40
41 #include "etherboot.h"
42 #include "nic.h"
43 #include <gpxe/pci.h>
44 #include <gpxe/ethernet.h>
45
46 #include "via-velocity.h"
47
48 typedef int pci_power_t;
49
50 #define PCI_D0  ((int) 0)
51 #define PCI_D1  ((int) 1)
52 #define PCI_D2  ((int) 2)
53 #define PCI_D3hot       ((int) 3)
54 #define PCI_D3cold      ((int) 4)
55 #define PCI_POWER_ERROR ((int) -1)
56
57
58 /* Condensed operations for readability. */
59 #define virt_to_le32desc(addr)  cpu_to_le32(virt_to_bus(addr))
60 #define le32desc_to_virt(addr)  bus_to_virt(le32_to_cpu(addr))
61
62 //FIXME: Move to pci.c
63 int pci_set_power_state(struct pci_device *dev, int state);
64
65 /* FIXME: Move BASE to the private structure */
66 static u32 BASE;
67
68 /* NIC specific static variables go here */
69 #define VELOCITY_PARAM(N,D) \
70         static const int N[MAX_UNITS]=OPTION_DEFAULT;
71 /*        MODULE_PARM(N, "1-" __MODULE_STRING(MAX_UNITS) "i");\
72         MODULE_PARM_DESC(N, D); */
73
74 VELOCITY_PARAM(RxDescriptors, "Number of receive descriptors");
75 VELOCITY_PARAM(TxDescriptors, "Number of transmit descriptors");
76
77
78 #define VLAN_ID_MIN     0
79 #define VLAN_ID_MAX     4095
80 #define VLAN_ID_DEF     0
81 /* VID_setting[] is used for setting the VID of NIC.
82    0: default VID.
83    1-4094: other VIDs.
84 */
85 VELOCITY_PARAM(VID_setting, "802.1Q VLAN ID");
86
87 #define RX_THRESH_MIN   0
88 #define RX_THRESH_MAX   3
89 #define RX_THRESH_DEF   0
90 /* rx_thresh[] is used for controlling the receive fifo threshold.
91    0: indicate the rxfifo threshold is 128 bytes.
92    1: indicate the rxfifo threshold is 512 bytes.
93    2: indicate the rxfifo threshold is 1024 bytes.
94    3: indicate the rxfifo threshold is store & forward.
95 */
96 VELOCITY_PARAM(rx_thresh, "Receive fifo threshold");
97
98 #define DMA_LENGTH_MIN  0
99 #define DMA_LENGTH_MAX  7
100 #define DMA_LENGTH_DEF  0
101
102 /* DMA_length[] is used for controlling the DMA length
103    0: 8 DWORDs
104    1: 16 DWORDs
105    2: 32 DWORDs
106    3: 64 DWORDs
107    4: 128 DWORDs
108    5: 256 DWORDs
109    6: SF(flush till emply)
110    7: SF(flush till emply)
111 */
112 VELOCITY_PARAM(DMA_length, "DMA length");
113
114 #define TAGGING_DEF     0
115 /* enable_tagging[] is used for enabling 802.1Q VID tagging.
116    0: disable VID seeting(default).
117    1: enable VID setting.
118 */
119 VELOCITY_PARAM(enable_tagging, "Enable 802.1Q tagging");
120
121 #define IP_ALIG_DEF     0
122 /* IP_byte_align[] is used for IP header DWORD byte aligned
123    0: indicate the IP header won't be DWORD byte aligned.(Default) .
124    1: indicate the IP header will be DWORD byte aligned.
125       In some enviroment, the IP header should be DWORD byte aligned,
126       or the packet will be droped when we receive it. (eg: IPVS)
127 */
128 VELOCITY_PARAM(IP_byte_align, "Enable IP header dword aligned");
129
130 #define TX_CSUM_DEF     1
131 /* txcsum_offload[] is used for setting the checksum offload ability of NIC.
132    (We only support RX checksum offload now)
133    0: disable csum_offload[checksum offload
134    1: enable checksum offload. (Default)
135 */
136 VELOCITY_PARAM(txcsum_offload, "Enable transmit packet checksum offload");
137
138 #define FLOW_CNTL_DEF   1
139 #define FLOW_CNTL_MIN   1
140 #define FLOW_CNTL_MAX   5
141
142 /* flow_control[] is used for setting the flow control ability of NIC.
143    1: hardware deafult - AUTO (default). Use Hardware default value in ANAR.
144    2: enable TX flow control.
145    3: enable RX flow control.
146    4: enable RX/TX flow control.
147    5: disable
148 */
149 VELOCITY_PARAM(flow_control, "Enable flow control ability");
150
151 #define MED_LNK_DEF 0
152 #define MED_LNK_MIN 0
153 #define MED_LNK_MAX 4
154 /* speed_duplex[] is used for setting the speed and duplex mode of NIC.
155    0: indicate autonegotiation for both speed and duplex mode
156    1: indicate 100Mbps half duplex mode
157    2: indicate 100Mbps full duplex mode
158    3: indicate 10Mbps half duplex mode
159    4: indicate 10Mbps full duplex mode
160
161    Note:
162         if EEPROM have been set to the force mode, this option is ignored
163             by driver.
164 */
165 VELOCITY_PARAM(speed_duplex, "Setting the speed and duplex mode");
166
167 #define VAL_PKT_LEN_DEF     0
168 /* ValPktLen[] is used for setting the checksum offload ability of NIC.
169    0: Receive frame with invalid layer 2 length (Default)
170    1: Drop frame with invalid layer 2 length
171 */
172 VELOCITY_PARAM(ValPktLen, "Receiving or Drop invalid 802.3 frame");
173
174 #define WOL_OPT_DEF     0
175 #define WOL_OPT_MIN     0
176 #define WOL_OPT_MAX     7
177 /* wol_opts[] is used for controlling wake on lan behavior.
178    0: Wake up if recevied a magic packet. (Default)
179    1: Wake up if link status is on/off.
180    2: Wake up if recevied an arp packet.
181    4: Wake up if recevied any unicast packet.
182    Those value can be sumed up to support more than one option.
183 */
184 VELOCITY_PARAM(wol_opts, "Wake On Lan options");
185
186 #define INT_WORKS_DEF   20
187 #define INT_WORKS_MIN   10
188 #define INT_WORKS_MAX   64
189
190 VELOCITY_PARAM(int_works, "Number of packets per interrupt services");
191
192 /* The descriptors for this card are required to be aligned on
193 64 byte boundaries.  As the align attribute does not guarantee alignment
194 greater than the alignment of the start address (which for Etherboot
195 is 16 bytes of alignment) it requires some extra steps.  Add 64 to the 
196 size of the array and the init_ring adjusts the alignment */
197
198 /* Define the TX Descriptor */
199 static u8 tx_ring[TX_DESC_DEF * sizeof(struct tx_desc) + 64];
200
201 /* Create a static buffer of size PKT_BUF_SZ for each TX Descriptor.  
202 All descriptors point to a part of this buffer */
203 static u8 txb[(TX_DESC_DEF * PKT_BUF_SZ) + 64];
204
205 /* Define the RX Descriptor */
206 static u8 rx_ring[RX_DESC_DEF * sizeof(struct rx_desc) + 64];
207
208 /* Create a static buffer of size PKT_BUF_SZ for each RX Descriptor
209    All descriptors point to a part of this buffer */
210 static u8 rxb[(RX_DESC_DEF * PKT_BUF_SZ) + 64];
211
212 static void velocity_init_info(struct pci_device *pdev,
213                                struct velocity_info *vptr,
214                                struct velocity_info_tbl *info);
215 static int velocity_get_pci_info(struct velocity_info *,
216                                  struct pci_device *pdev);
217 static int velocity_open(struct nic *nic, struct pci_device *pci);
218
219 static int velocity_soft_reset(struct velocity_info *vptr);
220 static void velocity_init_cam_filter(struct velocity_info *vptr);
221 static void mii_init(struct velocity_info *vptr, u32 mii_status);
222 static u32 velocity_get_opt_media_mode(struct velocity_info *vptr);
223 static void velocity_print_link_status(struct velocity_info *vptr);
224 static void safe_disable_mii_autopoll(struct mac_regs *regs);
225 static void enable_flow_control_ability(struct velocity_info *vptr);
226 static void enable_mii_autopoll(struct mac_regs *regs);
227 static int velocity_mii_read(struct mac_regs *, u8 byIdx, u16 * pdata);
228 static int velocity_mii_write(struct mac_regs *, u8 byMiiAddr, u16 data);
229 static u32 mii_check_media_mode(struct mac_regs *regs);
230 static u32 check_connection_type(struct mac_regs *regs);
231 static int velocity_set_media_mode(struct velocity_info *vptr,
232                                    u32 mii_status);
233
234
235 /*
236  *      Internal board variants. At the moment we have only one
237  */
238
239 static struct velocity_info_tbl chip_info_table[] = {
240         {CHIP_TYPE_VT6110,
241          "VIA Networking Velocity Family Gigabit Ethernet Adapter", 256, 1,
242          0x00FFFFFFUL},
243         {0, NULL, 0, 0, 0}
244 };
245
246 /**
247  *      velocity_set_int_opt    -       parser for integer options
248  *      @opt: pointer to option value
249  *      @val: value the user requested (or -1 for default)
250  *      @min: lowest value allowed
251  *      @max: highest value allowed
252  *      @def: default value
253  *      @name: property name
254  *      @dev: device name
255  *
256  *      Set an integer property in the module options. This function does
257  *      all the verification and checking as well as reporting so that
258  *      we don't duplicate code for each option.
259  */
260
261 static void velocity_set_int_opt(int *opt, int val, int min, int max,
262                                  int def, char *name, char *devname)
263 {
264         if (val == -1) {
265                 printf("%s: set value of parameter %s to %d\n",
266                        devname, name, def);
267                 *opt = def;
268         } else if (val < min || val > max) {
269                 printf
270                     ("%s: the value of parameter %s is invalid, the valid range is (%d-%d)\n",
271                      devname, name, min, max);
272                 *opt = def;
273         } else {
274                 printf("%s: set value of parameter %s to %d\n",
275                        devname, name, val);
276                 *opt = val;
277         }
278 }
279
280 /**
281  *      velocity_set_bool_opt   -       parser for boolean options
282  *      @opt: pointer to option value
283  *      @val: value the user requested (or -1 for default)
284  *      @def: default value (yes/no)
285  *      @flag: numeric value to set for true.
286  *      @name: property name
287  *      @dev: device name
288  *
289  *      Set a boolean property in the module options. This function does
290  *      all the verification and checking as well as reporting so that
291  *      we don't duplicate code for each option.
292  */
293
294 static void velocity_set_bool_opt(u32 * opt, int val, int def, u32 flag,
295                                   char *name, char *devname)
296 {
297         (*opt) &= (~flag);
298         if (val == -1) {
299                 printf("%s: set parameter %s to %s\n",
300                        devname, name, def ? "TRUE" : "FALSE");
301                 *opt |= (def ? flag : 0);
302         } else if (val < 0 || val > 1) {
303                 printf
304                     ("%s: the value of parameter %s is invalid, the valid range is (0-1)\n",
305                      devname, name);
306                 *opt |= (def ? flag : 0);
307         } else {
308                 printf("%s: set parameter %s to %s\n",
309                        devname, name, val ? "TRUE" : "FALSE");
310                 *opt |= (val ? flag : 0);
311         }
312 }
313
314 /**
315  *      velocity_get_options    -       set options on device
316  *      @opts: option structure for the device
317  *      @index: index of option to use in module options array
318  *      @devname: device name
319  *
320  *      Turn the module and command options into a single structure
321  *      for the current device
322  */
323
324 static void velocity_get_options(struct velocity_opt *opts, int index,
325                                  char *devname)
326 {
327
328         /* FIXME Do the options need to be configurable */
329         velocity_set_int_opt(&opts->rx_thresh, -1, RX_THRESH_MIN,
330                              RX_THRESH_MAX, RX_THRESH_DEF, "rx_thresh",
331                              devname);
332         velocity_set_int_opt(&opts->DMA_length, DMA_length[index],
333                              DMA_LENGTH_MIN, DMA_LENGTH_MAX,
334                              DMA_LENGTH_DEF, "DMA_length", devname);
335         velocity_set_int_opt(&opts->numrx, RxDescriptors[index],
336                              RX_DESC_MIN, RX_DESC_MAX, RX_DESC_DEF,
337                              "RxDescriptors", devname);
338         velocity_set_int_opt(&opts->numtx, TxDescriptors[index],
339                              TX_DESC_MIN, TX_DESC_MAX, TX_DESC_DEF,
340                              "TxDescriptors", devname);
341         velocity_set_int_opt(&opts->vid, VID_setting[index], VLAN_ID_MIN,
342                              VLAN_ID_MAX, VLAN_ID_DEF, "VID_setting",
343                              devname);
344         velocity_set_bool_opt(&opts->flags, enable_tagging[index],
345                               TAGGING_DEF, VELOCITY_FLAGS_TAGGING,
346                               "enable_tagging", devname);
347         velocity_set_bool_opt(&opts->flags, txcsum_offload[index],
348                               TX_CSUM_DEF, VELOCITY_FLAGS_TX_CSUM,
349                               "txcsum_offload", devname);
350         velocity_set_int_opt(&opts->flow_cntl, flow_control[index],
351                              FLOW_CNTL_MIN, FLOW_CNTL_MAX, FLOW_CNTL_DEF,
352                              "flow_control", devname);
353         velocity_set_bool_opt(&opts->flags, IP_byte_align[index],
354                               IP_ALIG_DEF, VELOCITY_FLAGS_IP_ALIGN,
355                               "IP_byte_align", devname);
356         velocity_set_bool_opt(&opts->flags, ValPktLen[index],
357                               VAL_PKT_LEN_DEF, VELOCITY_FLAGS_VAL_PKT_LEN,
358                               "ValPktLen", devname);
359         velocity_set_int_opt((int *) &opts->spd_dpx, speed_duplex[index],
360                              MED_LNK_MIN, MED_LNK_MAX, MED_LNK_DEF,
361                              "Media link mode", devname);
362         velocity_set_int_opt((int *) &opts->wol_opts, wol_opts[index],
363                              WOL_OPT_MIN, WOL_OPT_MAX, WOL_OPT_DEF,
364                              "Wake On Lan options", devname);
365         velocity_set_int_opt((int *) &opts->int_works, int_works[index],
366                              INT_WORKS_MIN, INT_WORKS_MAX, INT_WORKS_DEF,
367                              "Interrupt service works", devname);
368         opts->numrx = (opts->numrx & ~3);
369 }
370
371 /**
372  *      velocity_init_cam_filter        -       initialise CAM
373  *      @vptr: velocity to program
374  *
375  *      Initialize the content addressable memory used for filters. Load
376  *      appropriately according to the presence of VLAN
377  */
378
379 static void velocity_init_cam_filter(struct velocity_info *vptr)
380 {
381         struct mac_regs *regs = vptr->mac_regs;
382
383         /* Turn on MCFG_PQEN, turn off MCFG_RTGOPT */
384         WORD_REG_BITS_SET(MCFG_PQEN, MCFG_RTGOPT, &regs->MCFG);
385         WORD_REG_BITS_ON(MCFG_VIDFR, &regs->MCFG);
386
387         /* Disable all CAMs */
388         memset(vptr->vCAMmask, 0, sizeof(u8) * 8);
389         memset(vptr->mCAMmask, 0, sizeof(u8) * 8);
390         mac_set_cam_mask(regs, vptr->vCAMmask, VELOCITY_VLAN_ID_CAM);
391         mac_set_cam_mask(regs, vptr->mCAMmask, VELOCITY_MULTICAST_CAM);
392
393         /* Enable first VCAM */
394         if (vptr->flags & VELOCITY_FLAGS_TAGGING) {
395                 /* If Tagging option is enabled and VLAN ID is not zero, then
396                    turn on MCFG_RTGOPT also */
397                 if (vptr->options.vid != 0)
398                         WORD_REG_BITS_ON(MCFG_RTGOPT, &regs->MCFG);
399
400                 mac_set_cam(regs, 0, (u8 *) & (vptr->options.vid),
401                             VELOCITY_VLAN_ID_CAM);
402                 vptr->vCAMmask[0] |= 1;
403                 mac_set_cam_mask(regs, vptr->vCAMmask,
404                                  VELOCITY_VLAN_ID_CAM);
405         } else {
406                 u16 temp = 0;
407                 mac_set_cam(regs, 0, (u8 *) & temp, VELOCITY_VLAN_ID_CAM);
408                 temp = 1;
409                 mac_set_cam_mask(regs, (u8 *) & temp,
410                                  VELOCITY_VLAN_ID_CAM);
411         }
412 }
413
414 static inline void velocity_give_many_rx_descs(struct velocity_info *vptr)
415 {
416         struct mac_regs *regs = vptr->mac_regs;
417         int avail, dirty, unusable;
418
419         /*
420          * RD number must be equal to 4X per hardware spec
421          * (programming guide rev 1.20, p.13)
422          */
423         if (vptr->rd_filled < 4)
424                 return;
425
426         wmb();
427
428         unusable = vptr->rd_filled & 0x0003;
429         dirty = vptr->rd_dirty - unusable;
430         for (avail = vptr->rd_filled & 0xfffc; avail; avail--) {
431                 dirty = (dirty > 0) ? dirty - 1 : vptr->options.numrx - 1;
432 //              printf("return dirty: %d\n", dirty);
433                 vptr->rd_ring[dirty].rdesc0.owner = OWNED_BY_NIC;
434         }
435
436         writew(vptr->rd_filled & 0xfffc, &regs->RBRDU);
437         vptr->rd_filled = unusable;
438 }
439
440 static int velocity_rx_refill(struct velocity_info *vptr)
441 {
442         int dirty = vptr->rd_dirty, done = 0, ret = 0;
443
444 //      printf("rx_refill - rd_curr = %d, dirty = %d\n", vptr->rd_curr, dirty);
445         do {
446                 struct rx_desc *rd = vptr->rd_ring + dirty;
447
448                 /* Fine for an all zero Rx desc at init time as well */
449                 if (rd->rdesc0.owner == OWNED_BY_NIC)
450                         break;
451 //              printf("rx_refill - after owner %d\n", dirty);
452
453                 rd->inten = 1;
454                 rd->pa_high = 0;
455                 rd->rdesc0.len = cpu_to_le32(vptr->rx_buf_sz);;
456
457                 done++;
458                 dirty = (dirty < vptr->options.numrx - 1) ? dirty + 1 : 0;
459         } while (dirty != vptr->rd_curr);
460
461         if (done) {
462 //              printf("\nGive Back Desc\n");
463                 vptr->rd_dirty = dirty;
464                 vptr->rd_filled += done;
465                 velocity_give_many_rx_descs(vptr);
466         }
467
468         return ret;
469 }
470
471 extern void hex_dump(const char *data, const unsigned int len);
472 /**************************************************************************
473 POLL - Wait for a frame
474 ***************************************************************************/
475 //EB53 static int velocity_poll(struct nic *nic, int retrieve)
476 static int  velocity_poll(struct nic *nic __unused)
477 {
478         /* Work out whether or not there's an ethernet packet ready to
479          * read.  Return 0 if not.
480          */
481
482         int rd_curr = vptr->rd_curr % RX_DESC_DEF;
483         struct rx_desc *rd = &(vptr->rd_ring[rd_curr]);
484
485         if (rd->rdesc0.owner == OWNED_BY_NIC)
486                 return 0;
487         rmb();
488
489         /*
490          *      Don't drop CE or RL error frame although RXOK is off
491          */
492         if ((rd->rdesc0.RSR & RSR_RXOK)
493             || (!(rd->rdesc0.RSR & RSR_RXOK)
494                 && (rd->rdesc0.RSR & (RSR_CE | RSR_RL)))) {
495
496                 nic->packetlen = rd->rdesc0.len;
497                 // ptr->rxb + (rd_curr * PKT_BUF_SZ)
498                 memcpy(nic->packet, bus_to_virt(rd->pa_low),
499                        nic->packetlen - 4);
500
501                 vptr->rd_curr++;
502                 vptr->rd_curr = vptr->rd_curr % RX_DESC_DEF;
503                 velocity_rx_refill(vptr);
504                 return 1;       /* Remove this line once this method is implemented */
505         }
506         return 0;
507 }
508
509 #define TX_TIMEOUT  (1000);
510 /**************************************************************************
511 TRANSMIT - Transmit a frame
512 ***************************************************************************/
513 static void velocity_transmit(struct nic *nic, const char *dest,        /* Destination */
514                               unsigned int type,        /* Type */
515                               unsigned int size,        /* size */
516                               const char *packet)
517 {                               /* Packet */
518         u16 nstype;
519         u32 to;
520         u8 *ptxb;
521         unsigned int pktlen;
522         struct tx_desc *td_ptr;
523
524         int entry = vptr->td_curr % TX_DESC_DEF;
525         td_ptr = &(vptr->td_rings[entry]);
526
527         /* point to the current txb incase multiple tx_rings are used */
528         ptxb = vptr->txb + (entry * PKT_BUF_SZ);
529         memcpy(ptxb, dest, ETH_ALEN);   /* Destination */
530         memcpy(ptxb + ETH_ALEN, nic->node_addr, ETH_ALEN);      /* Source */
531         nstype = htons((u16) type);     /* Type */
532         memcpy(ptxb + 2 * ETH_ALEN, (u8 *) & nstype, 2);        /* Type */
533         memcpy(ptxb + ETH_HLEN, packet, size);
534
535         td_ptr->tdesc1.TCPLS = TCPLS_NORMAL;
536         td_ptr->tdesc1.TCR = TCR0_TIC;
537         td_ptr->td_buf[0].queue = 0;
538
539         size += ETH_HLEN;
540         while (size < ETH_ZLEN) /* pad to min length */
541                 ptxb[size++] = '\0';
542
543         if (size < ETH_ZLEN) {
544 //              printf("Padd that packet\n");
545                 pktlen = ETH_ZLEN;
546 //                memcpy(ptxb, skb->data, skb->len);
547                 memset(ptxb + size, 0, ETH_ZLEN - size);
548
549                 vptr->td_rings[entry].tdesc0.pktsize = pktlen;
550                 vptr->td_rings[entry].td_buf[0].pa_low = virt_to_bus(ptxb);
551                 vptr->td_rings[entry].td_buf[0].pa_high &=
552                     cpu_to_le32(0xffff0000L);
553                 vptr->td_rings[entry].td_buf[0].bufsize =
554                     vptr->td_rings[entry].tdesc0.pktsize;
555                 vptr->td_rings[entry].tdesc1.CMDZ = 2;
556         } else {
557 //              printf("Correct size packet\n");
558                 td_ptr->tdesc0.pktsize = size;
559                 td_ptr->td_buf[0].pa_low = virt_to_bus(ptxb);
560                 td_ptr->td_buf[0].pa_high = 0;
561                 td_ptr->td_buf[0].bufsize = td_ptr->tdesc0.pktsize;
562 //                tdinfo->nskb_dma = 1;
563                 td_ptr->tdesc1.CMDZ = 2;
564         }
565
566         if (vptr->flags & VELOCITY_FLAGS_TAGGING) {
567                 td_ptr->tdesc1.pqinf.VID = (vptr->options.vid & 0xfff);
568                 td_ptr->tdesc1.pqinf.priority = 0;
569                 td_ptr->tdesc1.pqinf.CFI = 0;
570                 td_ptr->tdesc1.TCR |= TCR0_VETAG;
571         }
572
573         vptr->td_curr = (entry + 1);
574
575         {
576
577                 int prev = entry - 1;
578
579                 if (prev < 0)
580                         prev = TX_DESC_DEF - 1;
581                 td_ptr->tdesc0.owner |= OWNED_BY_NIC;
582                 td_ptr = &(vptr->td_rings[prev]);
583                 td_ptr->td_buf[0].queue = 1;
584                 mac_tx_queue_wake(vptr->mac_regs, 0);
585
586         }
587
588         to = currticks() + TX_TIMEOUT;
589         while ((td_ptr->tdesc0.owner & OWNED_BY_NIC) && (currticks() < to));    /* wait */
590
591         if (currticks() >= to) {
592                 printf("TX Time Out");
593         }
594
595 }
596
597 /**************************************************************************
598 DISABLE - Turn off ethernet interface
599 ***************************************************************************/
600 static void velocity_disable(struct nic *nic __unused)
601 {
602         /* put the card in its initial state */
603         /* This function serves 3 purposes.
604          * This disables DMA and interrupts so we don't receive
605          *  unexpected packets or interrupts from the card after
606          *  etherboot has finished. 
607          * This frees resources so etherboot may use
608          *  this driver on another interface
609          * This allows etherboot to reinitialize the interface
610          *  if something is something goes wrong.
611          */
612         struct mac_regs *regs = vptr->mac_regs;
613         mac_disable_int(regs);
614         writel(CR0_STOP, &regs->CR0Set);
615         writew(0xFFFF, &regs->TDCSRClr);
616         writeb(0xFF, &regs->RDCSRClr);
617         safe_disable_mii_autopoll(regs);
618         mac_clear_isr(regs);
619
620         /* Power down the chip */
621 //      pci_set_power_state(vptr->pdev, PCI_D3hot);
622
623         vptr->flags &= (~VELOCITY_FLAGS_OPENED);
624 }
625
626 /**************************************************************************
627 IRQ - handle interrupts
628 ***************************************************************************/
629 static void velocity_irq(struct nic *nic __unused, irq_action_t action)
630 {
631         /* This routine is somewhat optional.  Etherboot itself
632          * doesn't use interrupts, but they are required under some
633          * circumstances when we're acting as a PXE stack.
634          *
635          * If you don't implement this routine, the only effect will
636          * be that your driver cannot be used via Etherboot's UNDI
637          * API.  This won't affect programs that use only the UDP
638          * portion of the PXE API, such as pxelinux.
639          */
640
641         switch (action) {
642         case DISABLE:
643         case ENABLE:
644                 /* Set receive interrupt enabled/disabled state */
645                 /*
646                    outb ( action == ENABLE ? IntrMaskEnabled : IntrMaskDisabled,
647                    nic->ioaddr + IntrMaskRegister );
648                  */
649                 break;
650         case FORCE:
651                 /* Force NIC to generate a receive interrupt */
652                 /*
653                    outb ( ForceInterrupt, nic->ioaddr + IntrForceRegister );
654                  */
655                 break;
656         }
657 }
658
659 static struct nic_operations velocity_operations = {
660         .connect        = dummy_connect,
661         .poll           = velocity_poll,
662         .transmit       = velocity_transmit,
663         .irq            = velocity_irq,
664 };
665
666 /**************************************************************************
667 PROBE - Look for an adapter, this routine's visible to the outside
668 ***************************************************************************/
669 static int velocity_probe(struct pci_device *dev, struct pci_device *pci)
670 {
671         struct nic *nic = (struct nic *) dev;
672         int ret, i;
673         struct mac_regs *regs;
674
675         printf("via-velocity.c: Found %s Vendor=0x%hX Device=0x%hX\n",
676                pci->driver_name, pci->vendor, pci->device);
677
678         /* point to private storage */
679         vptr = &vptx;
680         info = chip_info_table;
681
682         velocity_init_info(pci, vptr, info);
683
684 //FIXME: pci_enable_device(pci);
685 //FIXME: pci_set_power_state(pci, PCI_D0);
686
687         ret = velocity_get_pci_info(vptr, pci);
688         if (ret < 0) {
689                 printf("Failed to find PCI device.\n");
690                 return 0;
691         }
692
693         regs = ioremap(vptr->memaddr, vptr->io_size);
694         if (regs == NULL) {
695                 printf("Unable to remap io\n");
696                 return 0;
697         }
698
699         vptr->mac_regs = regs;
700
701         BASE = vptr->ioaddr;
702
703         printf("Chip ID: %hX\n", vptr->chip_id);
704
705         for (i = 0; i < 6; i++)
706                 nic->node_addr[i] = readb(&regs->PAR[i]);
707
708         DBG ( "%s: %s at ioaddr %#hX\n", pci->driver_name, eth_ntoa ( nic->node_addr ), BASE );
709
710         velocity_get_options(&vptr->options, 0, pci->driver_name);
711
712         /* 
713          *      Mask out the options cannot be set to the chip
714          */
715         vptr->options.flags &= 0x00FFFFFFUL;    //info->flags = 0x00FFFFFFUL;
716
717         /*
718          *      Enable the chip specified capbilities
719          */
720
721         vptr->flags =
722             vptr->options.
723             flags | (0x00FFFFFFUL /*info->flags */  & 0xFF000000UL);
724
725         vptr->wol_opts = vptr->options.wol_opts;
726         vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
727
728         vptr->phy_id = MII_GET_PHY_ID(vptr->mac_regs);
729
730         if (vptr->flags & VELOCITY_FLAGS_TX_CSUM) {
731                 printf("features missing\n");
732         }
733
734         /* and leave the chip powered down */
735 // FIXME:       pci_set_power_state(pci, PCI_D3hot);
736
737         check_connection_type(vptr->mac_regs);
738         velocity_open(nic, pci);
739
740         /* store NIC parameters */
741         nic->nic_op = &velocity_operations;
742         return 1;
743 }
744
745 //#define IORESOURCE_IO              0x00000100      /* Resource type */
746
747 /**
748  *      velocity_init_info      -       init private data
749  *      @pdev: PCI device
750  *      @vptr: Velocity info
751  *      @info: Board type
752  *
753  *      Set up the initial velocity_info struct for the device that has been
754  *      discovered.
755  */
756
757 static void velocity_init_info(struct pci_device *pdev,
758                                struct velocity_info *vptr,
759                                struct velocity_info_tbl *info)
760 {
761         memset(vptr, 0, sizeof(struct velocity_info));
762
763         vptr->pdev = pdev;
764         vptr->chip_id = info->chip_id;
765         vptr->io_size = info->io_size;
766         vptr->num_txq = info->txqueue;
767         vptr->multicast_limit = MCAM_SIZE;
768
769         printf
770             ("chip_id: 0x%hX, io_size: %d, num_txq %d, multicast_limit: %d\n",
771              vptr->chip_id, vptr->io_size, vptr->num_txq,
772              vptr->multicast_limit);
773         printf("Name: %s\n", info->name);
774
775 //      spin_lock_init(&vptr->lock);
776 //      INIT_LIST_HEAD(&vptr->list);
777 }
778
779 /**
780  *      velocity_get_pci_info   -       retrieve PCI info for device
781  *      @vptr: velocity device
782  *      @pdev: PCI device it matches
783  *
784  *      Retrieve the PCI configuration space data that interests us from
785  *      the kernel PCI layer
786  */
787
788 #define IORESOURCE_IO   0x00000100      /* Resource type */
789 #define IORESOURCE_PREFETCH        0x00001000   /* No side effects */
790
791 #define IORESOURCE_MEM             0x00000200
792 #define BAR_0           0
793 #define BAR_1           1
794 #define BAR_5           5
795 #define  PCI_BASE_ADDRESS_SPACE 0x01    /* 0 = memory, 1 = I/O */
796 #define  PCI_BASE_ADDRESS_SPACE_IO 0x01
797 #define  PCI_BASE_ADDRESS_SPACE_MEMORY 0x00
798 #define  PCI_BASE_ADDRESS_MEM_TYPE_MASK 0x06
799 #define  PCI_BASE_ADDRESS_MEM_TYPE_32   0x00    /* 32 bit address */
800 #define  PCI_BASE_ADDRESS_MEM_TYPE_1M   0x02    /* Below 1M [obsolete] */
801 #define  PCI_BASE_ADDRESS_MEM_TYPE_64   0x04    /* 64 bit address */
802 #define  PCI_BASE_ADDRESS_MEM_PREFETCH  0x08    /* prefetchable? */
803 //#define  PCI_BASE_ADDRESS_MEM_MASK      (~0x0fUL)
804 // #define  PCI_BASE_ADDRESS_IO_MASK       (~0x03UL)
805
806 unsigned long pci_resource_flags(struct pci_device *pdev, unsigned int bar)
807 {
808         uint32_t l, sz;
809         unsigned long flags = 0;
810
811         pci_read_config_dword(pdev, bar, &l);
812         pci_write_config_dword(pdev, bar, ~0);
813         pci_read_config_dword(pdev, bar, &sz);
814         pci_write_config_dword(pdev, bar, l);
815
816         if (!sz || sz == 0xffffffff)
817                 printf("Weird size\n");
818         if (l == 0xffffffff)
819                 l = 0;
820         if ((l & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_MEMORY) {
821                 /*    sz = pci_size(l, sz, PCI_BASE_ADDRESS_MEM_MASK);
822                    if (!sz)
823                    continue;
824                    res->start = l & PCI_BASE_ADDRESS_MEM_MASK;
825                  */ flags |= l & ~PCI_BASE_ADDRESS_MEM_MASK;
826                 printf("Memory Resource\n");
827         } else {
828                 //            sz = pci_size(l, sz, PCI_BASE_ADDRESS_IO_MASK & 0xffff);
829                 ///         if (!sz)
830                 ///              continue;
831 //              res->start = l & PCI_BASE_ADDRESS_IO_MASK;
832                 flags |= l & ~PCI_BASE_ADDRESS_IO_MASK;
833                 printf("I/O Resource\n");
834         }
835         if (flags & PCI_BASE_ADDRESS_SPACE_IO) {
836                 printf("Why is it here\n");
837                 flags |= IORESOURCE_IO;
838         } else {
839                 printf("here\n");
840 //flags &= ~IORESOURCE_IO;
841         }
842
843
844         if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
845                 flags |= IORESOURCE_MEM | IORESOURCE_PREFETCH;
846
847
848         return flags;
849 }
850 static int velocity_get_pci_info(struct velocity_info *vptr,
851                                  struct pci_device *pdev)
852 {
853         if (pci_read_config_byte(pdev, PCI_REVISION_ID, &vptr->rev_id) < 0) {
854                 printf("DEBUG: pci_read_config_byte failed\n");
855                 return -1;
856         }
857
858         adjust_pci_device(pdev);
859
860         vptr->ioaddr = pci_bar_start(pdev, PCI_BASE_ADDRESS_0);
861         vptr->memaddr = pci_bar_start(pdev, PCI_BASE_ADDRESS_1);
862
863         printf("Looking for I/O Resource - Found:");
864         if (!
865             (pci_resource_flags(pdev, PCI_BASE_ADDRESS_0) & IORESOURCE_IO))
866         {
867                 printf
868                     ("DEBUG: region #0 is not an I/O resource, aborting.\n");
869                 return -1;
870         }
871
872         printf("Looking for Memory Resource - Found:");
873         if ((pci_resource_flags(pdev, PCI_BASE_ADDRESS_1) & IORESOURCE_IO)) {
874                 printf("DEBUG: region #1 is an I/O resource, aborting.\n");
875                 return -1;
876         }
877
878         if (pci_bar_size(pdev, PCI_BASE_ADDRESS_1) < 256) {
879                 printf("DEBUG: region #1 is too small.\n");
880                 return -1;
881         }
882         vptr->pdev = pdev;
883
884         return 0;
885 }
886
887 /**
888  *      velocity_print_link_status      -       link status reporting
889  *      @vptr: velocity to report on
890  *
891  *      Turn the link status of the velocity card into a kernel log
892  *      description of the new link state, detailing speed and duplex
893  *      status
894  */
895
896 static void velocity_print_link_status(struct velocity_info *vptr)
897 {
898
899         if (vptr->mii_status & VELOCITY_LINK_FAIL) {
900                 printf("failed to detect cable link\n");
901         } else if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
902                 printf("Link autonegation");
903
904                 if (vptr->mii_status & VELOCITY_SPEED_1000)
905                         printf(" speed 1000M bps");
906                 else if (vptr->mii_status & VELOCITY_SPEED_100)
907                         printf(" speed 100M bps");
908                 else
909                         printf(" speed 10M bps");
910
911                 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
912                         printf(" full duplex\n");
913                 else
914                         printf(" half duplex\n");
915         } else {
916                 printf("Link forced");
917                 switch (vptr->options.spd_dpx) {
918                 case SPD_DPX_100_HALF:
919                         printf(" speed 100M bps half duplex\n");
920                         break;
921                 case SPD_DPX_100_FULL:
922                         printf(" speed 100M bps full duplex\n");
923                         break;
924                 case SPD_DPX_10_HALF:
925                         printf(" speed 10M bps half duplex\n");
926                         break;
927                 case SPD_DPX_10_FULL:
928                         printf(" speed 10M bps full duplex\n");
929                         break;
930                 default:
931                         break;
932                 }
933         }
934 }
935
936 /**
937  *      velocity_rx_reset       -       handle a receive reset
938  *      @vptr: velocity we are resetting
939  *
940  *      Reset the ownership and status for the receive ring side.
941  *      Hand all the receive queue to the NIC.
942  */
943
944 static void velocity_rx_reset(struct velocity_info *vptr)
945 {
946
947         struct mac_regs *regs = vptr->mac_regs;
948         int i;
949
950 //ptr->rd_dirty = vptr->rd_filled = vptr->rd_curr = 0;
951
952         /*
953          *      Init state, all RD entries belong to the NIC
954          */
955         for (i = 0; i < vptr->options.numrx; ++i)
956                 vptr->rd_ring[i].rdesc0.owner = OWNED_BY_NIC;
957
958         writew(RX_DESC_DEF, &regs->RBRDU);
959         writel(virt_to_le32desc(vptr->rd_ring), &regs->RDBaseLo);
960         writew(0, &regs->RDIdx);
961         writew(RX_DESC_DEF - 1, &regs->RDCSize);
962 }
963
964 /**
965  *      velocity_init_registers -       initialise MAC registers
966  *      @vptr: velocity to init
967  *      @type: type of initialisation (hot or cold)
968  *
969  *      Initialise the MAC on a reset or on first set up on the
970  *      hardware.
971  */
972
973 static void velocity_init_registers(struct nic *nic,
974                                     struct velocity_info *vptr,
975                                     enum velocity_init_type type)
976 {
977         struct mac_regs *regs = vptr->mac_regs;
978         int i, mii_status;
979
980         mac_wol_reset(regs);
981
982         switch (type) {
983         case VELOCITY_INIT_RESET:
984         case VELOCITY_INIT_WOL:
985
986 //netif_stop_queue(vptr->dev);
987
988                 /*
989                  *      Reset RX to prevent RX pointer not on the 4X location
990                  */
991                 velocity_rx_reset(vptr);
992                 mac_rx_queue_run(regs);
993                 mac_rx_queue_wake(regs);
994
995                 mii_status = velocity_get_opt_media_mode(vptr);
996
997                 if (velocity_set_media_mode(vptr, mii_status) !=
998                     VELOCITY_LINK_CHANGE) {
999                         velocity_print_link_status(vptr);
1000                         if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
1001                                 printf("Link Failed\n");
1002 //                              netif_wake_queue(vptr->dev);
1003                 }
1004
1005                 enable_flow_control_ability(vptr);
1006
1007                 mac_clear_isr(regs);
1008                 writel(CR0_STOP, &regs->CR0Clr);
1009                 //writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT), 
1010                 writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT),
1011                        &regs->CR0Set);
1012                 break;
1013
1014         case VELOCITY_INIT_COLD:
1015         default:
1016                 /*
1017                  *      Do reset
1018                  */
1019                 velocity_soft_reset(vptr);
1020                 mdelay(5);
1021
1022                 mac_eeprom_reload(regs);
1023                 for (i = 0; i < 6; i++) {
1024                         writeb(nic->node_addr[i], &(regs->PAR[i]));
1025                 }
1026                 /*
1027                  *      clear Pre_ACPI bit.
1028                  */
1029                 BYTE_REG_BITS_OFF(CFGA_PACPI, &(regs->CFGA));
1030                 mac_set_rx_thresh(regs, vptr->options.rx_thresh);
1031                 mac_set_dma_length(regs, vptr->options.DMA_length);
1032
1033                 writeb(WOLCFG_SAM | WOLCFG_SAB, &regs->WOLCFGSet);
1034                 /*
1035                  *      Back off algorithm use original IEEE standard
1036                  */
1037                 BYTE_REG_BITS_SET(CFGB_OFSET,
1038                                   (CFGB_CRANDOM | CFGB_CAP | CFGB_MBA |
1039                                    CFGB_BAKOPT), &regs->CFGB);
1040
1041                 /*
1042                  *      Init CAM filter
1043                  */
1044                 velocity_init_cam_filter(vptr);
1045
1046                 /*
1047                  *      Set packet filter: Receive directed and broadcast address
1048                  */
1049 //FIXME Multicast               velocity_set_multi(nic);
1050
1051                 /*
1052                  *      Enable MII auto-polling
1053                  */
1054                 enable_mii_autopoll(regs);
1055
1056                 vptr->int_mask = INT_MASK_DEF;
1057
1058                 writel(virt_to_le32desc(vptr->rd_ring), &regs->RDBaseLo);
1059                 writew(vptr->options.numrx - 1, &regs->RDCSize);
1060                 mac_rx_queue_run(regs);
1061                 mac_rx_queue_wake(regs);
1062
1063                 writew(vptr->options.numtx - 1, &regs->TDCSize);
1064
1065 //              for (i = 0; i < vptr->num_txq; i++) {
1066                 writel(virt_to_le32desc(vptr->td_rings),
1067                        &(regs->TDBaseLo[0]));
1068                 mac_tx_queue_run(regs, 0);
1069 //              }
1070
1071                 init_flow_control_register(vptr);
1072
1073                 writel(CR0_STOP, &regs->CR0Clr);
1074                 writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT),
1075                        &regs->CR0Set);
1076
1077                 mii_status = velocity_get_opt_media_mode(vptr);
1078 //              netif_stop_queue(vptr->dev);
1079
1080                 mii_init(vptr, mii_status);
1081
1082                 if (velocity_set_media_mode(vptr, mii_status) !=
1083                     VELOCITY_LINK_CHANGE) {
1084                         velocity_print_link_status(vptr);
1085                         if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
1086                                 printf("Link Faaailll\n");
1087 //                              netif_wake_queue(vptr->dev);
1088                 }
1089
1090                 enable_flow_control_ability(vptr);
1091                 mac_hw_mibs_init(regs);
1092                 mac_write_int_mask(vptr->int_mask, regs);
1093                 mac_clear_isr(regs);
1094
1095
1096         }
1097         velocity_print_link_status(vptr);
1098 }
1099
1100 /**
1101  *      velocity_soft_reset     -       soft reset
1102  *      @vptr: velocity to reset
1103  *
1104  *      Kick off a soft reset of the velocity adapter and then poll
1105  *      until the reset sequence has completed before returning.
1106  */
1107
1108 static int velocity_soft_reset(struct velocity_info *vptr)
1109 {
1110         struct mac_regs *regs = vptr->mac_regs;
1111         unsigned int i = 0;
1112
1113         writel(CR0_SFRST, &regs->CR0Set);
1114
1115         for (i = 0; i < W_MAX_TIMEOUT; i++) {
1116                 udelay(5);
1117                 if (!DWORD_REG_BITS_IS_ON(CR0_SFRST, &regs->CR0Set))
1118                         break;
1119         }
1120
1121         if (i == W_MAX_TIMEOUT) {
1122                 writel(CR0_FORSRST, &regs->CR0Set);
1123                 /* FIXME: PCI POSTING */
1124                 /* delay 2ms */
1125                 mdelay(2);
1126         }
1127         return 0;
1128 }
1129
1130 /**
1131  *      velocity_init_rings     -       set up DMA rings
1132  *      @vptr: Velocity to set up
1133  *
1134  *      Allocate PCI mapped DMA rings for the receive and transmit layer
1135  *      to use.
1136  */
1137
1138 static int velocity_init_rings(struct velocity_info *vptr)
1139 {
1140
1141         int idx;
1142
1143         vptr->rd_curr = 0;
1144         vptr->td_curr = 0;
1145         memset(vptr->td_rings, 0, TX_DESC_DEF * sizeof(struct tx_desc));
1146         memset(vptr->rd_ring, 0, RX_DESC_DEF * sizeof(struct rx_desc));
1147 //      memset(vptr->tx_buffs, 0, TX_DESC_DEF * PKT_BUF_SZ);
1148
1149
1150         for (idx = 0; idx < RX_DESC_DEF; idx++) {
1151                 *((u32 *) & (vptr->rd_ring[idx].rdesc0)) = 0;
1152                 vptr->rd_ring[idx].len = cpu_to_le32(vptr->rx_buf_sz);
1153                 vptr->rd_ring[idx].inten = 1;
1154                 vptr->rd_ring[idx].pa_low =
1155                     virt_to_bus(vptr->rxb + (RX_DESC_DEF * idx));
1156                 vptr->rd_ring[idx].pa_high = 0;
1157                 vptr->rd_ring[idx].rdesc0.owner = OWNED_BY_NIC;
1158
1159         }
1160
1161 /*      for (i = 0; idx < TX_DESC_DEF; idx++ ) {
1162                 vptr->td_rings[idx].tdesc1.TCPLS = TCPLS_NORMAL;
1163                 vptr->td_rings[idx].tdesc1.TCR = TCR0_TIC;
1164                 vptr->td_rings[idx].td_buf[0].queue = 0;
1165                 vptr->td_rings[idx].tdesc0.owner = ~OWNED_BY_NIC;
1166                 vptr->td_rings[idx].tdesc0.pktsize = 0;
1167                 vptr->td_rings[idx].td_buf[0].pa_low = cpu_to_le32(virt_to_bus(vptr->txb + (idx * PKT_BUF_SZ)));
1168                 vptr->td_rings[idx].td_buf[0].pa_high = 0;
1169                 vptr->td_rings[idx].td_buf[0].bufsize = 0;
1170                 vptr->td_rings[idx].tdesc1.CMDZ = 2;
1171         }
1172 */
1173         return 0;
1174 }
1175
1176 /**
1177  *      velocity_open           -       interface activation callback
1178  *      @dev: network layer device to open
1179  *
1180  *      Called when the network layer brings the interface up. Returns
1181  *      a negative posix error code on failure, or zero on success.
1182  *
1183  *      All the ring allocation and set up is done on open for this
1184  *      adapter to minimise memory usage when inactive
1185  */
1186
1187 #define PCI_BYTE_REG_BITS_ON(x,i,p) do{\
1188     u8 byReg;\
1189     pci_read_config_byte((p), (i), &(byReg));\
1190     (byReg) |= (x);\
1191     pci_write_config_byte((p), (i), (byReg));\
1192 } while (0)
1193
1194 //
1195 // Registers in the PCI configuration space
1196 //
1197 #define PCI_REG_COMMAND         0x04    //
1198 #define PCI_REG_MODE0           0x60    //
1199 #define PCI_REG_MODE1           0x61    //
1200 #define PCI_REG_MODE2           0x62    //
1201 #define PCI_REG_MODE3           0x63    //
1202 #define PCI_REG_DELAY_TIMER     0x64    //
1203
1204 // Bits in the (MODE2, 0x62) register
1205 //
1206 #define MODE2_PCEROPT       0x80        // take PCI bus ERror as a fatal and shutdown from software control
1207 #define MODE2_TXQ16         0x40        // TX write-back Queue control. 0->32 entries available in Tx write-back queue, 1->16 entries
1208 #define MODE2_TXPOST        0x08        // (Not support in VT3119)
1209 #define MODE2_AUTOOPT       0x04        // (VT3119 GHCI without such behavior)
1210 #define MODE2_MODE10T       0x02        // used to control tx Threshold for 10M case
1211 #define MODE2_TCPLSOPT      0x01        // TCP large send field update disable, hardware will not update related fields, leave it to software.
1212
1213 //
1214 // Bits in the MODE3 register
1215 //
1216 #define MODE3_MIION         0x04        // MII symbol codine error detect enable ??
1217
1218 // Bits in the (COMMAND, 0x04) register
1219 #define COMMAND_BUSM        0x04
1220 #define COMMAND_WAIT        0x80
1221 static int velocity_open(struct nic *nic, struct pci_device *pci __unused)
1222 {
1223         int ret;
1224
1225         u8 diff;
1226         u32 TxPhyAddr, RxPhyAddr;
1227         u32 TxBufPhyAddr, RxBufPhyAddr;
1228         vptr->TxDescArrays = tx_ring;
1229         if (vptr->TxDescArrays == 0)
1230                 printf("Allot Error");
1231
1232         /* Tx Descriptor needs 64 bytes alignment; */
1233         TxPhyAddr = virt_to_bus(vptr->TxDescArrays);
1234         printf("Unaligned Address : %lX\n", TxPhyAddr);
1235         diff = 64 - (TxPhyAddr - ((TxPhyAddr >> 6) << 6));
1236         TxPhyAddr += diff;
1237         vptr->td_rings = (struct tx_desc *) (vptr->TxDescArrays + diff);
1238
1239         printf("Aligned Address: %lX\n", virt_to_bus(vptr->td_rings));
1240         vptr->tx_buffs = txb;
1241         /* Rx Buffer needs 64 bytes alignment; */
1242         TxBufPhyAddr = virt_to_bus(vptr->tx_buffs);
1243         diff = 64 - (TxBufPhyAddr - ((TxBufPhyAddr >> 6) << 6));
1244         TxBufPhyAddr += diff;
1245         vptr->txb = (unsigned char *) (vptr->tx_buffs + diff);
1246
1247         vptr->RxDescArrays = rx_ring;
1248         /* Rx Descriptor needs 64 bytes alignment; */
1249         RxPhyAddr = virt_to_bus(vptr->RxDescArrays);
1250         diff = 64 - (RxPhyAddr - ((RxPhyAddr >> 6) << 6));
1251         RxPhyAddr += diff;
1252         vptr->rd_ring = (struct rx_desc *) (vptr->RxDescArrays + diff);
1253
1254         vptr->rx_buffs = rxb;
1255         /* Rx Buffer needs 64 bytes alignment; */
1256         RxBufPhyAddr = virt_to_bus(vptr->rx_buffs);
1257         diff = 64 - (RxBufPhyAddr - ((RxBufPhyAddr >> 6) << 6));
1258         RxBufPhyAddr += diff;
1259         vptr->rxb = (unsigned char *) (vptr->rx_buffs + diff);
1260
1261         if (vptr->RxDescArrays == NULL || vptr->RxDescArrays == NULL) {
1262                 printf("Allocate tx_ring or rd_ring failed\n");
1263                 return 0;
1264         }
1265
1266         vptr->rx_buf_sz = PKT_BUF_SZ;
1267 /*
1268     // turn this on to avoid retry forever
1269     PCI_BYTE_REG_BITS_ON(MODE2_PCEROPT, PCI_REG_MODE2, pci);
1270     // for some legacy BIOS and OS don't open BusM
1271     // bit in PCI configuration space. So, turn it on.
1272     PCI_BYTE_REG_BITS_ON(COMMAND_BUSM, PCI_REG_COMMAND, pci);
1273     // turn this on to detect MII coding error
1274     PCI_BYTE_REG_BITS_ON(MODE3_MIION, PCI_REG_MODE3, pci);
1275  */
1276         ret = velocity_init_rings(vptr);
1277
1278         /* Ensure chip is running */
1279 //FIXME:        pci_set_power_state(vptr->pdev, PCI_D0);
1280
1281         velocity_init_registers(nic, vptr, VELOCITY_INIT_COLD);
1282         mac_write_int_mask(0, vptr->mac_regs);
1283 //      _int(vptr->mac_regs);
1284         //mac_enable_int(vptr->mac_regs);
1285
1286         vptr->flags |= VELOCITY_FLAGS_OPENED;
1287         return 1;
1288
1289 }
1290
1291 /*
1292  * MII access , media link mode setting functions
1293  */
1294
1295
1296 /**
1297  *      mii_init        -       set up MII
1298  *      @vptr: velocity adapter
1299  *      @mii_status:  links tatus
1300  *
1301  *      Set up the PHY for the current link state.
1302  */
1303
1304 static void mii_init(struct velocity_info *vptr, u32 mii_status __unused)
1305 {
1306         u16 BMCR;
1307
1308         switch (PHYID_GET_PHY_ID(vptr->phy_id)) {
1309         case PHYID_CICADA_CS8201:
1310                 /*
1311                  *      Reset to hardware default
1312                  */
1313                 MII_REG_BITS_OFF((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR,
1314                                  vptr->mac_regs);
1315                 /*
1316                  *      Turn on ECHODIS bit in NWay-forced full mode and turn it
1317                  *      off it in NWay-forced half mode for NWay-forced v.s. 
1318                  *      legacy-forced issue.
1319                  */
1320                 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1321                         MII_REG_BITS_ON(TCSR_ECHODIS, MII_REG_TCSR,
1322                                         vptr->mac_regs);
1323                 else
1324                         MII_REG_BITS_OFF(TCSR_ECHODIS, MII_REG_TCSR,
1325                                          vptr->mac_regs);
1326                 /*
1327                  *      Turn on Link/Activity LED enable bit for CIS8201
1328                  */
1329                 MII_REG_BITS_ON(PLED_LALBE, MII_REG_PLED, vptr->mac_regs);
1330                 break;
1331         case PHYID_VT3216_32BIT:
1332         case PHYID_VT3216_64BIT:
1333                 /*
1334                  *      Reset to hardware default
1335                  */
1336                 MII_REG_BITS_ON((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR,
1337                                 vptr->mac_regs);
1338                 /*
1339                  *      Turn on ECHODIS bit in NWay-forced full mode and turn it
1340                  *      off it in NWay-forced half mode for NWay-forced v.s. 
1341                  *      legacy-forced issue
1342                  */
1343                 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1344                         MII_REG_BITS_ON(TCSR_ECHODIS, MII_REG_TCSR,
1345                                         vptr->mac_regs);
1346                 else
1347                         MII_REG_BITS_OFF(TCSR_ECHODIS, MII_REG_TCSR,
1348                                          vptr->mac_regs);
1349                 break;
1350
1351         case PHYID_MARVELL_1000:
1352         case PHYID_MARVELL_1000S:
1353                 /*
1354                  *      Assert CRS on Transmit 
1355                  */
1356                 MII_REG_BITS_ON(PSCR_ACRSTX, MII_REG_PSCR, vptr->mac_regs);
1357                 /*
1358                  *      Reset to hardware default 
1359                  */
1360                 MII_REG_BITS_ON((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR,
1361                                 vptr->mac_regs);
1362                 break;
1363         default:
1364                 ;
1365         }
1366         velocity_mii_read(vptr->mac_regs, MII_REG_BMCR, &BMCR);
1367         if (BMCR & BMCR_ISO) {
1368                 BMCR &= ~BMCR_ISO;
1369                 velocity_mii_write(vptr->mac_regs, MII_REG_BMCR, BMCR);
1370         }
1371 }
1372
1373 /**
1374  *      safe_disable_mii_autopoll       -       autopoll off
1375  *      @regs: velocity registers
1376  *
1377  *      Turn off the autopoll and wait for it to disable on the chip
1378  */
1379
1380 static void safe_disable_mii_autopoll(struct mac_regs *regs)
1381 {
1382         u16 ww;
1383
1384         /*  turn off MAUTO */
1385         writeb(0, &regs->MIICR);
1386         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1387                 udelay(1);
1388                 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
1389                         break;
1390         }
1391 }
1392
1393 /**
1394  *      enable_mii_autopoll     -       turn on autopolling
1395  *      @regs: velocity registers
1396  *
1397  *      Enable the MII link status autopoll feature on the Velocity
1398  *      hardware. Wait for it to enable.
1399  */
1400
1401 static void enable_mii_autopoll(struct mac_regs *regs)
1402 {
1403         unsigned int ii;
1404
1405         writeb(0, &(regs->MIICR));
1406         writeb(MIIADR_SWMPL, &regs->MIIADR);
1407
1408         for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
1409                 udelay(1);
1410                 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
1411                         break;
1412         }
1413
1414         writeb(MIICR_MAUTO, &regs->MIICR);
1415
1416         for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
1417                 udelay(1);
1418                 if (!BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
1419                         break;
1420         }
1421
1422 }
1423
1424 /**
1425  *      velocity_mii_read       -       read MII data
1426  *      @regs: velocity registers
1427  *      @index: MII register index
1428  *      @data: buffer for received data
1429  *
1430  *      Perform a single read of an MII 16bit register. Returns zero
1431  *      on success or -ETIMEDOUT if the PHY did not respond.
1432  */
1433
1434 static int velocity_mii_read(struct mac_regs *regs, u8 index, u16 * data)
1435 {
1436         u16 ww;
1437
1438         /*
1439          *      Disable MIICR_MAUTO, so that mii addr can be set normally
1440          */
1441         safe_disable_mii_autopoll(regs);
1442
1443         writeb(index, &regs->MIIADR);
1444
1445         BYTE_REG_BITS_ON(MIICR_RCMD, &regs->MIICR);
1446
1447         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1448                 if (!(readb(&regs->MIICR) & MIICR_RCMD))
1449                         break;
1450         }
1451
1452         *data = readw(&regs->MIIDATA);
1453
1454         enable_mii_autopoll(regs);
1455         if (ww == W_MAX_TIMEOUT)
1456                 return -1;
1457         return 0;
1458 }
1459
1460 /**
1461  *      velocity_mii_write      -       write MII data
1462  *      @regs: velocity registers
1463  *      @index: MII register index
1464  *      @data: 16bit data for the MII register
1465  *
1466  *      Perform a single write to an MII 16bit register. Returns zero
1467  *      on success or -ETIMEDOUT if the PHY did not respond.
1468  */
1469
1470 static int velocity_mii_write(struct mac_regs *regs, u8 mii_addr, u16 data)
1471 {
1472         u16 ww;
1473
1474         /*
1475          *      Disable MIICR_MAUTO, so that mii addr can be set normally
1476          */
1477         safe_disable_mii_autopoll(regs);
1478
1479         /* MII reg offset */
1480         writeb(mii_addr, &regs->MIIADR);
1481         /* set MII data */
1482         writew(data, &regs->MIIDATA);
1483
1484         /* turn on MIICR_WCMD */
1485         BYTE_REG_BITS_ON(MIICR_WCMD, &regs->MIICR);
1486
1487         /* W_MAX_TIMEOUT is the timeout period */
1488         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
1489                 udelay(5);
1490                 if (!(readb(&regs->MIICR) & MIICR_WCMD))
1491                         break;
1492         }
1493         enable_mii_autopoll(regs);
1494
1495         if (ww == W_MAX_TIMEOUT)
1496                 return -1;
1497         return 0;
1498 }
1499
1500 /**
1501  *      velocity_get_opt_media_mode     -       get media selection
1502  *      @vptr: velocity adapter
1503  *
1504  *      Get the media mode stored in EEPROM or module options and load
1505  *      mii_status accordingly. The requested link state information
1506  *      is also returned.
1507  */
1508
1509 static u32 velocity_get_opt_media_mode(struct velocity_info *vptr)
1510 {
1511         u32 status = 0;
1512
1513         switch (vptr->options.spd_dpx) {
1514         case SPD_DPX_AUTO:
1515                 status = VELOCITY_AUTONEG_ENABLE;
1516                 break;
1517         case SPD_DPX_100_FULL:
1518                 status = VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL;
1519                 break;
1520         case SPD_DPX_10_FULL:
1521                 status = VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL;
1522                 break;
1523         case SPD_DPX_100_HALF:
1524                 status = VELOCITY_SPEED_100;
1525                 break;
1526         case SPD_DPX_10_HALF:
1527                 status = VELOCITY_SPEED_10;
1528                 break;
1529         }
1530         vptr->mii_status = status;
1531         return status;
1532 }
1533
1534 /**
1535  *      mii_set_auto_on         -       autonegotiate on
1536  *      @vptr: velocity
1537  *
1538  *      Enable autonegotation on this interface
1539  */
1540
1541 static void mii_set_auto_on(struct velocity_info *vptr)
1542 {
1543         if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs))
1544                 MII_REG_BITS_ON(BMCR_REAUTO, MII_REG_BMCR, vptr->mac_regs);
1545         else
1546                 MII_REG_BITS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs);
1547 }
1548
1549
1550 /*
1551 static void mii_set_auto_off(struct velocity_info * vptr)
1552 {
1553     MII_REG_BITS_OFF(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs);
1554 }
1555 */
1556
1557 /**
1558  *      set_mii_flow_control    -       flow control setup
1559  *      @vptr: velocity interface
1560  *
1561  *      Set up the flow control on this interface according to
1562  *      the supplied user/eeprom options.
1563  */
1564
1565 static void set_mii_flow_control(struct velocity_info *vptr)
1566 {
1567         /*Enable or Disable PAUSE in ANAR */
1568         switch (vptr->options.flow_cntl) {
1569         case FLOW_CNTL_TX:
1570                 MII_REG_BITS_OFF(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
1571                 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
1572                 break;
1573
1574         case FLOW_CNTL_RX:
1575                 MII_REG_BITS_ON(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
1576                 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
1577                 break;
1578
1579         case FLOW_CNTL_TX_RX:
1580                 MII_REG_BITS_ON(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
1581                 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
1582                 break;
1583
1584         case FLOW_CNTL_DISABLE:
1585                 MII_REG_BITS_OFF(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
1586                 MII_REG_BITS_OFF(ANAR_ASMDIR, MII_REG_ANAR,
1587                                  vptr->mac_regs);
1588                 break;
1589         default:
1590                 break;
1591         }
1592 }
1593
1594 /**
1595  *      velocity_set_media_mode         -       set media mode
1596  *      @mii_status: old MII link state
1597  *
1598  *      Check the media link state and configure the flow control
1599  *      PHY and also velocity hardware setup accordingly. In particular
1600  *      we need to set up CD polling and frame bursting.
1601  */
1602
1603 static int velocity_set_media_mode(struct velocity_info *vptr,
1604                                    u32 mii_status)
1605 {
1606         u32 curr_status;
1607         struct mac_regs *regs = vptr->mac_regs;
1608
1609         vptr->mii_status = mii_check_media_mode(vptr->mac_regs);
1610         curr_status = vptr->mii_status & (~VELOCITY_LINK_FAIL);
1611
1612         /* Set mii link status */
1613         set_mii_flow_control(vptr);
1614
1615         /*
1616            Check if new status is consisent with current status
1617            if (((mii_status & curr_status) & VELOCITY_AUTONEG_ENABLE)
1618            || (mii_status==curr_status)) {
1619            vptr->mii_status=mii_check_media_mode(vptr->mac_regs);
1620            vptr->mii_status=check_connection_type(vptr->mac_regs);
1621            printf(MSG_LEVEL_INFO, "Velocity link no change\n");
1622            return 0;
1623            }
1624          */
1625
1626         if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201) {
1627                 MII_REG_BITS_ON(AUXCR_MDPPS, MII_REG_AUXCR,
1628                                 vptr->mac_regs);
1629         }
1630
1631         /*
1632          *      If connection type is AUTO
1633          */
1634         if (mii_status & VELOCITY_AUTONEG_ENABLE) {
1635                 printf("Velocity is AUTO mode\n");
1636                 /* clear force MAC mode bit */
1637                 BYTE_REG_BITS_OFF(CHIPGCR_FCMODE, &regs->CHIPGCR);
1638                 /* set duplex mode of MAC according to duplex mode of MII */
1639                 MII_REG_BITS_ON(ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10,
1640                                 MII_REG_ANAR, vptr->mac_regs);
1641                 MII_REG_BITS_ON(G1000CR_1000FD | G1000CR_1000,
1642                                 MII_REG_G1000CR, vptr->mac_regs);
1643                 MII_REG_BITS_ON(BMCR_SPEED1G, MII_REG_BMCR,
1644                                 vptr->mac_regs);
1645
1646                 /* enable AUTO-NEGO mode */
1647                 mii_set_auto_on(vptr);
1648         } else {
1649                 u16 ANAR;
1650                 u8 CHIPGCR;
1651
1652                 /*
1653                  * 1. if it's 3119, disable frame bursting in halfduplex mode
1654                  *    and enable it in fullduplex mode
1655                  * 2. set correct MII/GMII and half/full duplex mode in CHIPGCR
1656                  * 3. only enable CD heart beat counter in 10HD mode
1657                  */
1658
1659                 /* set force MAC mode bit */
1660                 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
1661
1662                 CHIPGCR = readb(&regs->CHIPGCR);
1663                 CHIPGCR &= ~CHIPGCR_FCGMII;
1664
1665                 if (mii_status & VELOCITY_DUPLEX_FULL) {
1666                         CHIPGCR |= CHIPGCR_FCFDX;
1667                         writeb(CHIPGCR, &regs->CHIPGCR);
1668                         printf
1669                             ("DEBUG: set Velocity to forced full mode\n");
1670                         if (vptr->rev_id < REV_ID_VT3216_A0)
1671                                 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
1672                 } else {
1673                         CHIPGCR &= ~CHIPGCR_FCFDX;
1674                         printf
1675                             ("DEBUG: set Velocity to forced half mode\n");
1676                         writeb(CHIPGCR, &regs->CHIPGCR);
1677                         if (vptr->rev_id < REV_ID_VT3216_A0)
1678                                 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
1679                 }
1680
1681                 MII_REG_BITS_OFF(G1000CR_1000FD | G1000CR_1000,
1682                                  MII_REG_G1000CR, vptr->mac_regs);
1683
1684                 if (!(mii_status & VELOCITY_DUPLEX_FULL)
1685                     && (mii_status & VELOCITY_SPEED_10)) {
1686                         BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
1687                 } else {
1688                         BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
1689                 }
1690                 /* MII_REG_BITS_OFF(BMCR_SPEED1G, MII_REG_BMCR, vptr->mac_regs); */
1691                 velocity_mii_read(vptr->mac_regs, MII_REG_ANAR, &ANAR);
1692                 ANAR &= (~(ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10));
1693                 if (mii_status & VELOCITY_SPEED_100) {
1694                         if (mii_status & VELOCITY_DUPLEX_FULL)
1695                                 ANAR |= ANAR_TXFD;
1696                         else
1697                                 ANAR |= ANAR_TX;
1698                 } else {
1699                         if (mii_status & VELOCITY_DUPLEX_FULL)
1700                                 ANAR |= ANAR_10FD;
1701                         else
1702                                 ANAR |= ANAR_10;
1703                 }
1704                 velocity_mii_write(vptr->mac_regs, MII_REG_ANAR, ANAR);
1705                 /* enable AUTO-NEGO mode */
1706                 mii_set_auto_on(vptr);
1707                 /* MII_REG_BITS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs); */
1708         }
1709         /* vptr->mii_status=mii_check_media_mode(vptr->mac_regs); */
1710         /* vptr->mii_status=check_connection_type(vptr->mac_regs); */
1711         return VELOCITY_LINK_CHANGE;
1712 }
1713
1714 /**
1715  *      mii_check_media_mode    -       check media state
1716  *      @regs: velocity registers
1717  *
1718  *      Check the current MII status and determine the link status
1719  *      accordingly
1720  */
1721
1722 static u32 mii_check_media_mode(struct mac_regs *regs)
1723 {
1724         u32 status = 0;
1725         u16 ANAR;
1726
1727         if (!MII_REG_BITS_IS_ON(BMSR_LNK, MII_REG_BMSR, regs))
1728                 status |= VELOCITY_LINK_FAIL;
1729
1730         if (MII_REG_BITS_IS_ON(G1000CR_1000FD, MII_REG_G1000CR, regs))
1731                 status |= VELOCITY_SPEED_1000 | VELOCITY_DUPLEX_FULL;
1732         else if (MII_REG_BITS_IS_ON(G1000CR_1000, MII_REG_G1000CR, regs))
1733                 status |= (VELOCITY_SPEED_1000);
1734         else {
1735                 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
1736                 if (ANAR & ANAR_TXFD)
1737                         status |=
1738                             (VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL);
1739                 else if (ANAR & ANAR_TX)
1740                         status |= VELOCITY_SPEED_100;
1741                 else if (ANAR & ANAR_10FD)
1742                         status |=
1743                             (VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL);
1744                 else
1745                         status |= (VELOCITY_SPEED_10);
1746         }
1747
1748         if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, regs)) {
1749                 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
1750                 if ((ANAR & (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10))
1751                     == (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)) {
1752                         if (MII_REG_BITS_IS_ON
1753                             (G1000CR_1000 | G1000CR_1000FD,
1754                              MII_REG_G1000CR, regs))
1755                                 status |= VELOCITY_AUTONEG_ENABLE;
1756                 }
1757         }
1758
1759         return status;
1760 }
1761
1762 static u32 check_connection_type(struct mac_regs *regs)
1763 {
1764         u32 status = 0;
1765         u8 PHYSR0;
1766         u16 ANAR;
1767         PHYSR0 = readb(&regs->PHYSR0);
1768
1769         /*
1770            if (!(PHYSR0 & PHYSR0_LINKGD))
1771            status|=VELOCITY_LINK_FAIL;
1772          */
1773
1774         if (PHYSR0 & PHYSR0_FDPX)
1775                 status |= VELOCITY_DUPLEX_FULL;
1776
1777         if (PHYSR0 & PHYSR0_SPDG)
1778                 status |= VELOCITY_SPEED_1000;
1779         if (PHYSR0 & PHYSR0_SPD10)
1780                 status |= VELOCITY_SPEED_10;
1781         else
1782                 status |= VELOCITY_SPEED_100;
1783
1784         if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, regs)) {
1785                 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
1786                 if ((ANAR & (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10))
1787                     == (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)) {
1788                         if (MII_REG_BITS_IS_ON
1789                             (G1000CR_1000 | G1000CR_1000FD,
1790                              MII_REG_G1000CR, regs))
1791                                 status |= VELOCITY_AUTONEG_ENABLE;
1792                 }
1793         }
1794
1795         return status;
1796 }
1797
1798 /**
1799  *      enable_flow_control_ability     -       flow control
1800  *      @vptr: veloity to configure
1801  *
1802  *      Set up flow control according to the flow control options
1803  *      determined by the eeprom/configuration.
1804  */
1805
1806 static void enable_flow_control_ability(struct velocity_info *vptr)
1807 {
1808
1809         struct mac_regs *regs = vptr->mac_regs;
1810
1811         switch (vptr->options.flow_cntl) {
1812
1813         case FLOW_CNTL_DEFAULT:
1814                 if (BYTE_REG_BITS_IS_ON(PHYSR0_RXFLC, &regs->PHYSR0))
1815                         writel(CR0_FDXRFCEN, &regs->CR0Set);
1816                 else
1817                         writel(CR0_FDXRFCEN, &regs->CR0Clr);
1818
1819                 if (BYTE_REG_BITS_IS_ON(PHYSR0_TXFLC, &regs->PHYSR0))
1820                         writel(CR0_FDXTFCEN, &regs->CR0Set);
1821                 else
1822                         writel(CR0_FDXTFCEN, &regs->CR0Clr);
1823                 break;
1824
1825         case FLOW_CNTL_TX:
1826                 writel(CR0_FDXTFCEN, &regs->CR0Set);
1827                 writel(CR0_FDXRFCEN, &regs->CR0Clr);
1828                 break;
1829
1830         case FLOW_CNTL_RX:
1831                 writel(CR0_FDXRFCEN, &regs->CR0Set);
1832                 writel(CR0_FDXTFCEN, &regs->CR0Clr);
1833                 break;
1834
1835         case FLOW_CNTL_TX_RX:
1836                 writel(CR0_FDXTFCEN, &regs->CR0Set);
1837                 writel(CR0_FDXRFCEN, &regs->CR0Set);
1838                 break;
1839
1840         case FLOW_CNTL_DISABLE:
1841                 writel(CR0_FDXRFCEN, &regs->CR0Clr);
1842                 writel(CR0_FDXTFCEN, &regs->CR0Clr);
1843                 break;
1844
1845         default:
1846                 break;
1847         }
1848
1849 }
1850
1851 /* FIXME: Move to pci.c */
1852 /**
1853  * pci_set_power_state - Set the power state of a PCI device
1854  * @dev: PCI device to be suspended
1855  * @state: Power state we're entering
1856  *
1857  * Transition a device to a new power state, using the Power Management 
1858  * Capabilities in the device's config space.
1859  *
1860  * RETURN VALUE: 
1861  * -EINVAL if trying to enter a lower state than we're already in.
1862  * 0 if we're already in the requested state.
1863  * -EIO if device does not support PCI PM.
1864  * 0 if we can successfully change the power state.
1865  */
1866
1867 int pci_set_power_state(struct pci_device *dev, int state)
1868 {
1869         int pm;
1870         u16 pmcsr;
1871         int current_state = 0;
1872
1873         /* bound the state we're entering */
1874         if (state > 3)
1875                 state = 3;
1876
1877         /* Validate current state:
1878          * Can enter D0 from any state, but if we can only go deeper 
1879          * to sleep if we're already in a low power state
1880          */
1881         if (state > 0 && current_state > state)
1882                 return -1;
1883         else if (current_state == state)
1884                 return 0;       /* we're already there */
1885
1886         /* find PCI PM capability in list */
1887         pm = pci_find_capability(dev, PCI_CAP_ID_PM);
1888
1889         /* abort if the device doesn't support PM capabilities */
1890         if (!pm)
1891                 return -2;
1892
1893         /* check if this device supports the desired state */
1894         if (state == 1 || state == 2) {
1895                 u16 pmc;
1896                 pci_read_config_word(dev, pm + PCI_PM_PMC, &pmc);
1897                 if (state == 1 && !(pmc & PCI_PM_CAP_D1))
1898                         return -2;
1899                 else if (state == 2 && !(pmc & PCI_PM_CAP_D2))
1900                         return -2;
1901         }
1902
1903         /* If we're in D3, force entire word to 0.
1904          * This doesn't affect PME_Status, disables PME_En, and
1905          * sets PowerState to 0.
1906          */
1907         if (current_state >= 3)
1908                 pmcsr = 0;
1909         else {
1910                 pci_read_config_word(dev, pm + PCI_PM_CTRL, &pmcsr);
1911                 pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
1912                 pmcsr |= state;
1913         }
1914
1915         /* enter specified state */
1916         pci_write_config_word(dev, pm + PCI_PM_CTRL, pmcsr);
1917
1918         /* Mandatory power management transition delays */
1919         /* see PCI PM 1.1 5.6.1 table 18 */
1920         if (state == 3 || current_state == 3)
1921                 mdelay(10);
1922         else if (state == 2 || current_state == 2)
1923                 udelay(200);
1924         current_state = state;
1925
1926         return 0;
1927 }
1928
1929 static struct pci_device_id velocity_nics[] = {
1930         PCI_ROM(0x1106, 0x3119, "via-velocity", "VIA Networking Velocity Family Gigabit Ethernet Adapter"),
1931 };
1932
1933 PCI_DRIVER ( velocity_driver, velocity_nics, PCI_NO_CLASS );
1934
1935 DRIVER ( "VIA-VELOCITY/PCI", nic_driver, pci_driver, velocity_driver,
1936          velocity_probe, velocity_disable );