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