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