?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.3.18pre1
[davej-history.git] / drivers / i2o / i2o_lan.c
blob863780f38ab8561e5fe8c8c04b7dfec58ff4d41d
1 /*
2 * linux/drivers/i2o/i2o_lan.c
3 *
4 * I2O LAN CLASS OSM Prototyping, July 16th 1999
5 *
6 * (C) Copyright 1999 University of Helsinki,
7 * Department of Computer Science
8 *
9 * This code is still under development / test.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
15 *
16 * Authors: Auvo Häkkinen <Auvo.Hakkinen@cs.Helsinki.FI>
17 * Juha Sievänen <Juha.Sievanen@cs.Helsinki.FI>
18 * Deepak Saxena <deepak@plexity.net>
19 *
20 * Tested: in FDDI environment (using SysKonnect's DDM)
21 * in Ethernet environment (using Intel 82558 DDM proto)
22 *
23 * TODO: batch mode networking
24 * - we've not been able to test batch replies and
25 * batch receives
26 * error checking / timeouts
27 * code / test for other LAN classes
28 */
29
30 #include <linux/config.h>
31 #include <linux/module.h>
32
33 #include <linux/netdevice.h>
34 #include <linux/etherdevice.h>
35 #include <linux/fddidevice.h>
36 #include <linux/skbuff.h>
37 #include <linux/if_arp.h>
38 #include <linux/malloc.h>
39 #include <linux/trdevice.h>
40 #include <linux/init.h>
41 #include <linux/spinlock.h>
42 #include <asm/io.h>
43
44 #include <linux/errno.h>
45
46 #include <linux/i2o.h>
47 #include "i2o_lan.h"
48
49 //#define DRIVERDEBUG
50 #ifdef DRIVERDEBUG
51 #define dprintk(s, args...) printk(s, ## args)
52 #else
53 #define dprintk(s, args...)
54 #endif
55
56 #define MAX_LAN_CARDS 4
57 static struct net_device *i2o_landevs[MAX_LAN_CARDS+1];
58 static int unit = -1; /* device unit number */
59
60 struct i2o_lan_local {
61 u8 unit;
62 struct i2o_device *i2o_dev;
63 int reply_flag; /* needed by scalar/table queries */
64 u32 packet_tresh; /* treshold for incoming skb's */
65 struct fddi_statistics stats; /* see also struct net_device_stats */
66 unsigned short (*type_trans)(struct sk_buff *, struct net_device *);
67 /*
68 * Due to way that interrupts can pile up, we need to keep track
69 * of buckets ourselves. Otherwise we'll end up flooding
70 * the DDM with buckets.
71 */
72 u32 bucket_count;
73 };
74
75 /* function prototypes */
76 static int i2o_lan_receive_post(struct net_device *dev);
77 static int i2o_lan_receive_post_reply(struct net_device *dev, struct i2o_message *m);
78 static void i2o_lan_release_buckets(u32 *msg, struct i2o_lan_local *priv);
79
80 /*
81 * Module params
82 */
83 static u32 bucketpost = I2O_BUCKET_COUNT;
84 static u32 bucketthresh = I2O_BUCKET_THRESH;
85 static u32 rx_copybreak = 200;
86
87 static void i2o_lan_reply(struct i2o_handler *h, struct i2o_controller *iop,
88 struct i2o_message *m)
89 {
90 u32 *msg = (u32 *)m;
91 u8 unit = (u8)(msg[2]>>16); // InitiatorContext
92 struct net_device *dev = i2o_landevs[unit];
93 struct i2o_lan_local *priv;
94
95 if(dev)
96 priv = (struct i2o_lan_local *)dev->priv;
97 else
98 priv = NULL;
99
100 dprintk("Unit: %d Function: %#x\n",
101 unit, msg[1]>>24);
102
103 if (msg[0] & (1<<13)) // Fail bit is set
104 {
105 printk(KERN_ERR "IOP failed to process the msg:\n");
106 printk(KERN_ERR " Cmd = 0x%02X, InitiatorTid = %d, TargetTid = %d\n",
107 (msg[1] >> 24) & 0xFF, (msg[1] >> 12) & 0xFFF, msg[1] & 0xFFF);
108 printk(KERN_ERR " FailureCode = 0x%02X\n Severity = 0x%02X\n "
109 "LowestVersion = 0x%02X\n HighestVersion = 0x%02X\n",
110 msg[4] >> 24, (msg[4] >> 16) & 0xFF,
111 (msg[4] >> 8) & 0xFF, msg[4] & 0xFF);
112 printk(KERN_ERR " FailingHostUnit = 0x%04X\n FailingIOP = 0x%03X\n",
113 msg[5] >> 16, msg[5] & 0xFFF);
114 return;
115 }
116
117 #ifndef DRIVERDEBUG
118 if (msg[4] >> 24) /* ReqStatus != SUCCESS */
119 #endif
120 i2o_report_status(KERN_INFO, dev->name, msg);
121
122 switch (msg[1] >> 24) {
123 case LAN_RECEIVE_POST:
124 {
125 if (dev->start)
126 {
127 if(!(msg[4]>>24))
128 {
129 i2o_lan_receive_post_reply(dev,m);
130 break;
131 }
132 else
133 {
134 // Something VERY wrong if this is happening
135 printk( KERN_WARNING "i2olan: Device %s rejected bucket post\n", dev->name);
136 i2o_lan_release_buckets(msg,priv);
137 }
138 }
139 else
140 {
141 i2o_lan_release_buckets(msg,priv);
142 }
143
144 break;
145 }
146
147 case LAN_PACKET_SEND:
148 case LAN_SDU_SEND:
149 {
150 u8 trl_count = msg[3] & 0x000000FF;
151
152 do { // The HDM has handled the outgoing packet
153 dev_kfree_skb((struct sk_buff *)msg[4 + trl_count]);
154 dprintk(KERN_INFO "%s: Request skb freed (trl_count=%d).\n",
155 dev->name,trl_count);
156 } while (--trl_count);
157
158 dev->tbusy = 0;
159 mark_bh(NET_BH); /* inform upper layers */
160
161 break;
162 }
163
164 default:
165 if (msg[2] & 0x80000000) // reply to a UtilParamsGet/Set
166 {
167 int *flag = (int *)msg[3]; // flag for i2o_post_wait
168 if (msg[4] >> 24) // ReqStatus != SUCCESS
169 {
170 *flag = -(msg[4] & 0xFFFF); // DetailedStatus
171 }
172 else
173 *flag = I2O_POST_WAIT_OK;
174 }
175 }
176 }
177
178 void i2o_lan_release_buckets(u32 *msg, struct i2o_lan_local *priv)
179 {
180 u8 trl_count = (u8)(msg[3] & 0x000000FF);
181 u32 *pskb = &msg[6];
182
183 while (trl_count)
184 {
185 dprintk("%s: Releasing unused sk_buff %p\n",dev->name,
186 (struct sk_buff*)(*pskb));
187 dev_kfree_skb((struct sk_buff*)(*pskb));
188 pskb++;
189 if(priv)
190 priv->bucket_count--;
191 trl_count--;
192 }
193 }
194
195 static struct i2o_handler i2o_lan_handler =
196 {
197 i2o_lan_reply,
198 "I2O Lan OSM",
199 0, // context
200 I2O_CLASS_LAN
201 };
202 static int lan_context;
203
204
205 static int i2o_lan_receive_post_reply(struct net_device *dev, struct i2o_message *m)
206 {
207 u32 *msg = (u32 *)m;
208 struct i2o_lan_local *priv = (struct i2o_lan_local *)dev->priv;
209 struct i2o_bucket_descriptor *bucket = (struct i2o_bucket_descriptor *)&msg[6];
210 struct i2o_packet_info *packet;
211
212 u8 trl_count = msg[3] & 0x000000FF;
213 struct sk_buff *skb, *newskb;
214
215 #if 0
216 dprintk(KERN_INFO "TrlFlags = 0x%02X, TrlElementSize = %d, TrlCount = %d\n"
217 "msgsize = %d, buckets_remaining = %d\n",
218 msg[3]>>24, msg[3]&0x0000FF00, trl_count, msg[0]>>16, msg[5]);
219 #endif
220
221 dprintk(KERN_INFO "Buckets_remaining = %d, bucket_count = %d\n",
222 msg[5], priv->bucket_count);
223
224 do {
225 skb = (struct sk_buff *)(bucket->context);
226 packet = (struct i2o_packet_info *)bucket->packet_info;
227 priv->bucket_count--;
228 #if 0
229 dprintk(KERN)INFO "flags = 0x%02X, offset = 0x%06X, status = 0x%02X, length = %d\n",
230 packet->flags, packet->offset, packet->status, packet->len);
231 #endif
232 if (packet->len < rx_copybreak) {
233 newskb = (struct sk_buff *)
234 dev_alloc_skb(packet->len+2);
235 if (newskb) {
236 skb_reserve(newskb,2);
237 memcpy(skb_put(newskb,packet->len),
238 skb->data, packet->len);
239 newskb->dev = dev;
240 newskb->protocol = priv->type_trans(newskb, dev);
241
242 netif_rx(newskb);
243 dev_kfree_skb(skb); // FIXME: reuse this skb?
244 }
245 else {
246 printk("I2OLAN-%s: Can't allocate skb.\n", dev->name);
247 return -ENOMEM;
248 }
249 } else {
250
251 skb_put(skb,packet->len);
252 skb->dev = dev;
253 skb->protocol = priv->type_trans(skb, dev);
254
255 netif_rx(skb);
256 }
257 dprintk(KERN_INFO "%s: Incoming packet (%d bytes) delivered "
258 "to upper level.\n",dev->name,packet->len);
259
260 bucket++; // to next Packet Descriptor Block
261 } while (--trl_count);
262
263 if (priv->bucket_count <= bucketthresh) // BucketsRemaining
264 {
265 dprintk("Bucket_count = %d, ",priv->bucket_count);
266 i2o_lan_receive_post(dev);
267 }
268
269
270 if((msg[4]& 0x0000ffff) == 0x05) // I2O_LAN_RECEIVE_OVERRUN
271 {
272 printk("Bucket overrun! priv->bucketcount = %d\n",
273 priv->bucket_count);
274 }
275
276 return 0;
277 }
278
279 /* ====================================================
280 * Interface to i2o: functions to send lan class request
281 */
282
283
284 /*
285 * i2o_lan_receive_post(): Post buckets to receive packets.
286 */
287 static int i2o_lan_receive_post(struct net_device *dev)
288 {
289 struct i2o_lan_local *priv = (struct i2o_lan_local *)dev->priv;
290 struct i2o_device *i2o_dev = priv->i2o_dev;
291 struct i2o_controller *iop = i2o_dev->controller;
292 struct sk_buff *skb;
293 u32 m; u32 *msg;
294
295 u32 bucket_len = (dev->mtu + dev->hard_header_len);
296 u32 bucket_count;
297 int n_elems = (iop->inbound_size - 16 ) / 12; /* msg header + SGLs */
298 u32 total = 0;
299 int i;
300
301 while (total < bucketpost)
302 {
303 m = I2O_POST_READ32(iop);
304 if (m == 0xFFFFFFFF)
305 return -ETIMEDOUT;
306 msg = bus_to_virt(iop->mem_offset + m);
307
308 bucket_count = (total + n_elems < bucketpost)
309 ? n_elems
310 : bucketpost - total;
311
312 msg[0] = I2O_MESSAGE_SIZE(4 + 3 * bucket_count) | SGL_OFFSET_4;
313 msg[1] = LAN_RECEIVE_POST<<24 | HOST_TID<<12 | i2o_dev->id;
314 msg[2] = priv->unit << 16 | lan_context; // InitiatorContext
315 msg[3] = bucket_count; // BucketCount
316
317 for (i = 0; i < bucket_count; i++)
318 {
319 skb = dev_alloc_skb(bucket_len + 2);
320 if (skb == NULL)
321 return -ENOMEM;
322 skb_reserve(skb, 2);
323
324 priv->bucket_count++;
325
326 msg[4 + 3*i] = 0x51000000 | bucket_len;
327 msg[5 + 3*i] = (u32)skb;
328 msg[6 + 3*i] = virt_to_bus(skb->data);
329 }
330 msg[4 + 3*i - 3] |= 0x80000000; // set LE flag
331 i2o_post_message(iop,m);
332
333 dprintk(KERN_INFO "%s: Sending %d buckets (size %d) to LAN HDM.\n",
334 dev->name, bucket_count, bucket_len);
335
336 total += bucket_count;
337 }
338
339 return 0;
340 }
341
342 /*
343 * i2o_lan_reset(): Reset the LAN adapter into the operational state and
344 * restore it to full operation.
345 */
346 static int i2o_lan_reset(struct net_device *dev)
347 {
348 struct i2o_lan_local *priv = (struct i2o_lan_local *)dev->priv;
349 struct i2o_device *i2o_dev = priv->i2o_dev;
350 struct i2o_controller *iop = i2o_dev->controller;
351 u32 msg[5];
352
353 msg[0] = FIVE_WORD_MSG_SIZE | SGL_OFFSET_0;
354 msg[1] = LAN_RESET<<24 | HOST_TID<<12 | i2o_dev->id;
355 msg[2] = priv->unit << 16 | lan_context; // InitiatorContext
356 msg[3] = 0; // TransactionContext
357 msg[4] = 1 << 16; // return posted buckets
358
359 if (i2o_post_this(iop, i2o_dev->id, msg, sizeof(msg)) < 0)
360 return -ETIMEDOUT;
361
362 return 0;
363 }
364
365 /*
366 * i2o_lan_suspend(): Put LAN adapter into a safe, non-active state.
367 * Reply to any LAN class message with status error_no_data_transfer
368 * / suspended.
369 */
370 static int i2o_lan_suspend(struct net_device *dev)
371 {
372 struct i2o_lan_local *priv = (struct i2o_lan_local *)dev->priv;
373 struct i2o_device *i2o_dev = priv->i2o_dev;
374 struct i2o_controller *iop = i2o_dev->controller;
375 u32 msg[5];
376
377 dprintk( "%s: LAN SUSPEND MESSAGE\n", dev->name );
378 msg[0] = FIVE_WORD_MSG_SIZE | SGL_OFFSET_0;
379 msg[1] = LAN_SUSPEND<<24 | HOST_TID<<12 | i2o_dev->id;
380 msg[2] = priv->unit << 16 | lan_context; // InitiatorContext
381 msg[3] = 0; // TransactionContext
382 msg[4] = 1 << 16; // return posted buckets
383
384 if (i2o_post_this(iop, i2o_dev->id, msg, sizeof(msg)) < 0)
385 return -ETIMEDOUT;
386
387 return 0;
388 }
389
390 /*
391 * Set DDM into batch mode.
392 */
393 static void i2o_set_batch_mode(struct net_device *dev)
394 {
395
396 /*
397 * NOTE: we have not been able to test batch mode
398 * since HDMs we have, don't implement it
399 */
400
401 struct i2o_lan_local *priv = (struct i2o_lan_local *)dev->priv;
402 struct i2o_device *i2o_dev = priv->i2o_dev;
403 struct i2o_controller *iop = i2o_dev->controller;
404 u32 val;
405
406 /* set LAN_BATCH_CONTROL attributes */
407
408 // enable batch mode, toggle automatically
409 val = 0x00000000;
410 // val = 0x00000001; // turn off batch mode
411 if (i2o_set_scalar(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0003, 0,
412 &val, 4, &priv->reply_flag) <0)
413 printk(KERN_WARNING "Unable to enter I2O LAN batch mode.\n");
414 else
415 dprintk(KERN_INFO "%s: I2O LAN batch mode enabled.\n",dev->name);
416 // dprintk(KERN_INFO "%s: I2O LAN batch mode disabled.\n",dev->name);
417 /*
418 * When PacketOrphanlimit is same as the maximum packet length,
419 * the packets will never be split into two separate buckets
420 */
421
422 /* set LAN_OPERATION attributes */
423
424 val = dev->mtu + dev->hard_header_len; // PacketOrphanLimit
425 if (i2o_set_scalar(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0004, 2,
426 &val, 4, &priv->reply_flag) < 0)
427 printk(KERN_WARNING "i2o_lan: Unable to set PacketOrphanLimit.\n");
428 else
429 dprintk(KERN_INFO "%s: PacketOrphanLimit set to %d\n",
430 dev->name,val);
431
432 return;
433 }
434
435 /*
436 * i2o_lan_open(): Open the device to send/receive packets via
437 * the network device.
438 */
439 static int i2o_lan_open(struct net_device *dev)
440 {
441 struct i2o_lan_local *priv = (struct i2o_lan_local *)dev->priv;
442 struct i2o_device *i2o_dev = priv->i2o_dev;
443 struct i2o_controller *iop = i2o_dev->controller;
444
445 /* if (i2o_issue_claim(iop, i2o_dev->id, priv->unit << 16 | lan_context, 1,
446 &priv->reply_flag) < 0)
447 */
448 if(i2o_claim_device(i2o_dev, &i2o_lan_handler, I2O_CLAIM_PRIMARY))
449 {
450 printk(KERN_WARNING "%s: Unable to claim the I2O LAN device.\n", dev->name);
451 return -EAGAIN;
452 }
453 dprintk(KERN_INFO "%s: I2O LAN device claimed (tid=%d).\n", dev->name, i2o_dev->id);
454
455 i2o_lan_reset(dev);
456
457 dev->tbusy = 0;
458 dev->start = 1;
459
460 priv->packet_tresh = dev->mtu - (dev->mtu >> 3);
461
462 i2o_set_batch_mode(dev);
463 i2o_lan_receive_post(dev);
464
465 MOD_INC_USE_COUNT;
466
467 return 0;
468 }
469
470 /*
471 * i2o_lan_close(): End the transfering.
472 */
473 static int i2o_lan_close(struct net_device *dev)
474 {
475 struct i2o_lan_local *priv = (struct i2o_lan_local *)dev->priv;
476 struct i2o_device *i2o_dev = priv->i2o_dev;
477 struct i2o_controller *iop = i2o_dev->controller;
478
479 dev->tbusy = 1;
480 dev->start = 0;
481
482 // This is the right place for LanSuspend, but it seems to cause
483 // a kernel crash when we are using 82558 HDM proto
484
485 i2o_lan_suspend(dev);
486
487 /*
488 if (i2o_issue_claim(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0,
489 &priv->reply_flag) < 0)
490 */
491
492 if(i2o_release_device(i2o_dev, &i2o_lan_handler, I2O_CLAIM_PRIMARY))
493 printk(KERN_WARNING "%s: Unable to unclaim I2O LAN device "
494 "(tid=%d)\n", dev->name, i2o_dev->id);
495
496 MOD_DEC_USE_COUNT;
497
498 return 0;
499 }
500
501 /*
502 * i2o_lan_sdu_send(): Send a packet, MAC header added by the HDM.
503 * Must be supported by Fibre Channel, optional for Ethernet/802.3,
504 * Token Ring, FDDI
505 */
506 static int i2o_lan_sdu_send(struct sk_buff *skb, struct net_device *dev)
507 {
508 #if 0
509 /* not yet tested */
510 struct i2o_lan_local *priv = (struct i2o_lan_local *)dev->priv;
511 struct i2o_device *i2o_dev = priv->i2o_dev;
512 struct i2o_controller *iop = i2o_dev->controller;
513 u32 m; u32 *msg;
514
515 dprintk(KERN_INFO "LanSDUSend called, skb->len = %d\n", skb->len);
516
517 m = I2O_POST_READ32(iop);
518 if (m == 0xFFFFFFFF)
519 {
520 dev_kfree_skb(skb);
521 return -ETIMEDOUT;
522 }
523 msg = bus_to_virt(iop->mem_offset + m);
524
525 msg[0] = NINE_WORD_MSG_SIZE | SGL_OFFSET_4;
526 msg[1] = LAN_SDU_SEND<<24 | HOST_TID<<12 | i2o_dev->id;
527 msg[2] = priv->unit << 16 | lan_context; // IntiatorContext
528 msg[3] = 1<<4; // TransmitControlWord: suppress CRC generation
529
530 // create a simple SGL, see fig. 3-26
531 // D7 = 1101 0111 = LE eob 0 1 LA dir bc1 bc0
532
533 msg[4] = 0xD7000000 | (skb->len); // no MAC hdr included
534 msg[5] = (u32)skb; // TransactionContext
535 memcpy(&msg[6], skb->data, 8); // Destination MAC Addr ??
536 msg[7] &= 0x0000FFFF; // followed by two bytes zeros
537 msg[8] = virt_to_bus(skb->data);
538 dev->trans_start = jiffies;
539 i2o_post_message(iop,m);
540
541 dprintk(KERN_INFO "%s: Packet (%d bytes) sent to network.\n",
542 dev->name,skb->len);
543 #endif
544 return 0;
545 }
546
547 /*
548 * i2o_lan_packet_send(): Send a packet as is, including the MAC header.
549 *
550 * Must be supported by Ethernet/802.3, Token Ring, FDDI, optional for
551 * Fibre Channel
552 */
553 static int i2o_lan_packet_send(struct sk_buff *skb, struct net_device *dev)
554 {
555 struct i2o_lan_local *priv = (struct i2o_lan_local *)dev->priv;
556 struct i2o_device *i2o_dev = priv->i2o_dev;
557 struct i2o_controller *iop = i2o_dev->controller;
558 u32 m; u32 *msg;
559
560 m = I2O_POST_READ32(iop);
561 if (m == 0xFFFFFFFF) {
562 dev_kfree_skb(skb);
563 return -ETIMEDOUT;
564 }
565 msg = bus_to_virt(iop->mem_offset + m);
566
567 msg[0] = SEVEN_WORD_MSG_SIZE | 1<<12 | SGL_OFFSET_4;
568 msg[1] = LAN_PACKET_SEND<<24 | HOST_TID<<12 | i2o_dev->id;
569 msg[2] = priv->unit << 16 | lan_context; // IntiatorContext
570 msg[3] = 1 << 4; // TransmitControlWord
571
572 // create a simple SGL, see fig. 3-26
573 // D5 = 1101 0101 = LE eob 0 1 LA dir bc1 bc0
574
575 msg[4] = 0xD5000000 | skb->len; // MAC hdr included
576 msg[5] = (u32)skb; // TransactionContext
577 msg[6] = virt_to_bus(skb->data);
578
579 i2o_post_message(iop,m);
580 dprintk(KERN_INFO "%s: Packet (%d bytes) sent to network.\n",
581 dev->name, skb->len);
582
583 return 0;
584 }
585
586 static struct net_device_stats *i2o_lan_get_stats(struct net_device *dev)
587 {
588 struct i2o_lan_local *priv = (struct i2o_lan_local *)dev->priv;
589 struct i2o_device *i2o_dev = priv->i2o_dev;
590 struct i2o_controller *iop = i2o_dev->controller;
591 u64 val64[16];
592 u64 supported_group[4] = { 0, 0, 0, 0 };
593
594 if (i2o_query_scalar(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0100, -1,
595 val64, sizeof(val64), &priv->reply_flag) < 0)
596 dprintk("%s: Unable to query LAN_HISTORICAL_STATS.\n",dev->name);
597 else {
598 dprintk("%s: LAN_HISTORICAL_STATS queried.\n",dev->name);
599 priv->stats.tx_packets = val64[0];
600 priv->stats.tx_bytes = val64[1];
601 priv->stats.rx_packets = val64[2];
602 priv->stats.rx_bytes = val64[3];
603 priv->stats.tx_errors = val64[4];
604 priv->stats.rx_errors = val64[5];
605 priv->stats.rx_dropped = val64[6];
606 }
607
608 i2o_query_scalar(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0180, -1,
609 &supported_group, sizeof(supported_group), &priv->reply_flag);
610
611 if (supported_group[2]) {
612 if (i2o_query_scalar(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0183, -1,
613 val64, sizeof(val64), &priv->reply_flag) < 0)
614 dprintk("%s: Unable to query LAN_OPTIONAL_RX_HISTORICAL_STATS.\n",dev->name);
615 else {
616 dprintk("%s: LAN_OPTIONAL_RX_HISTORICAL_STATS queried.\n",dev->name);
617 priv->stats.multicast = val64[4];
618 priv->stats.rx_length_errors = val64[10];
619 priv->stats.rx_crc_errors = val64[0];
620 }
621 }
622
623 if (i2o_dev->subclass == I2O_LAN_ETHERNET)
624 {
625 u64 supported_stats = 0;
626
627 if (i2o_query_scalar(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0200, -1,
628 val64, sizeof(val64), &priv->reply_flag) < 0)
629 dprintk("%s: Unable to query LAN_802_3_HISTORICAL_STATS.\n",dev->name);
630 else {
631 // dprintk("%s: LAN_802_3_HISTORICAL_STATS queried.\n",dev->name);
632 priv->stats.transmit_collision = val64[1] + val64[2];
633 priv->stats.rx_frame_errors = val64[0];
634 priv->stats.tx_carrier_errors = val64[6];
635 }
636
637 if (i2o_query_scalar(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0280, -1,
638 &supported_stats, 8, &priv->reply_flag) < 0)
639 dprintk("%s: Unable to query LAN_SUPPORTED_802_3_HISTORICAL_STATS\n", dev->name);
640
641 if (supported_stats != 0) {
642 if (i2o_query_scalar(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0281, -1,
643 val64, sizeof(val64), &priv->reply_flag) < 0)
644 dprintk("%s: Unable to query LAN_OPTIONAL_802_3_HISTORICAL_STATS.\n",dev->name);
645 else {
646 dprintk("%s: LAN_OPTIONAL_802_3_HISTORICAL_STATS queried.\n",dev->name);
647 if (supported_stats & 0x1)
648 priv->stats.rx_over_errors = val64[0];
649 if (supported_stats & 0x4)
650 priv->stats.tx_heartbeat_errors = val64[2];
651 }
652 }
653
654 }
655
656 #ifdef CONFIG_TR
657 if (i2o_dev->subclass == I2O_LAN_TR)
658 {
659 if (i2o_query_scalar(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0300, -1,
660 val64, sizeof(val64), &priv->reply_flag) < 0)
661 dprintk("%s: Unable to query LAN_802_5_HISTORICAL_STATS.\n",dev->name);
662 else {
663 struct tr_statistics *stats =
664 (struct tr_statistics *)&priv->stats;
665 // dprintk("%s: LAN_802_5_HISTORICAL_STATS queried.\n",dev->name);
666
667 stats->line_errors = val64[0];
668 stats->internal_errors = val64[7];
669 stats->burst_errors = val64[4];
670 stats->A_C_errors = val64[2];
671 stats->abort_delimiters = val64[3];
672 stats->lost_frames = val64[1];
673 /* stats->recv_congest_count = ?; FIXME ??*/
674 stats->frame_copied_errors = val64[5];
675 stats->frequency_errors = val64[6];
676 stats->token_errors = val64[9];
677 }
678 /* Token Ring optional stats not yet defined */
679 }
680 #endif
681
682 #ifdef CONFIG_FDDI
683 if (i2o_dev->subclass == I2O_LAN_FDDI)
684 {
685 if (i2o_query_scalar(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0400, -1,
686 val64, sizeof(val64), &priv->reply_flag) < 0)
687 dprintk("%s: Unable to query LAN_FDDI_HISTORICAL_STATS.\n",dev->name);
688 else {
689 // dprintk("%s: LAN_FDDI_HISTORICAL_STATS queried.\n",dev->name);
690 priv->stats.smt_cf_state = val64[0];
691 memcpy(priv->stats.mac_upstream_nbr, &val64[1], FDDI_K_ALEN);
692 memcpy(priv->stats.mac_downstream_nbr, &val64[2], FDDI_K_ALEN);
693 priv->stats.mac_error_cts = val64[3];
694 priv->stats.mac_lost_cts = val64[4];
695 priv->stats.mac_rmt_state = val64[5];
696 memcpy(priv->stats.port_lct_fail_cts, &val64[6], 8);
697 memcpy(priv->stats.port_lem_reject_cts, &val64[7], 8);
698 memcpy(priv->stats.port_lem_cts, &val64[8], 8);
699 memcpy(priv->stats.port_pcm_state, &val64[9], 8);
700 }
701 /* FDDI optional stats not yet defined */
702 }
703 #endif
704
705 return (struct net_device_stats *)&priv->stats;
706 }
707
708 /*
709 * i2o_lan_set_multicast_list(): Enable a network device to receive packets
710 * not send to the protocol address.
711 */
712 static void i2o_lan_set_multicast_list(struct net_device *dev)
713 {
714 struct i2o_lan_local *priv = (struct i2o_lan_local *)dev->priv;
715 struct i2o_device *i2o_dev = priv->i2o_dev;
716 struct i2o_controller *iop = i2o_dev->controller;
717 u32 filter_mask;
718 u32 work32[64];
719
720 dprintk(KERN_INFO "%s: Entered i2o_lan_set_multicast_list().\n", dev->name);
721
722 if (dev==NULL)
723 printk("dev is NULL\n");
724 else if (dev->priv==NULL)
725 printk("dev->priv is NULL\n");
726 else if (priv->i2o_dev==NULL)
727 printk("i2o_dev is NULL\n");
728 else if (i2o_dev->controller==NULL)
729 printk("iop is NULL\n");
730 else {
731 printk("Everything seems to be OK in i2o_lan_set_multicast_list().\n");
732 printk("id = %d, unit = %d, lan_context = %d\n",
733 i2o_dev->id, priv->unit, lan_context);
734 }
735
736 return;
737
738 /* FIXME: Why does the next call kill the interrupt handler?
739 * The same piece of code works fine in function lan_open(), and in i2o_proc.c
740 *
741 * *because its trying to sleep in an irq - this must be async - Alan
742 */
743
744 if (i2o_query_scalar(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0001, -1,
745 &work32, sizeof(work32), &priv->reply_flag) < 0 )
746 {
747 printk(KERN_WARNING "i2o_lan: Unable to query "
748 " LAN_MAC_ADDRESS table.\n");
749 return;
750 }
751 printk(KERN_INFO "capab mask = 0x%08X, filter mask = 0x%08X\n",
752 work32[7], work32[6]);
753
754 filter_mask = work32[6];
755
756 if (dev->flags & IFF_PROMISC)
757 {
758 filter_mask |= 0x00000002;
759 dprintk(KERN_INFO "i2o_lan: Enabling promiscuous mode...\n");
760 }
761
762 else if ((dev->flags & IFF_ALLMULTI) || dev->mc_count > work32[5])
763 {
764 filter_mask |= 0x00000000;
765 dprintk(KERN_INFO "i2o_lan: Enabling all multicast mode...\n");
766 }
767
768 else if (dev->mc_count)
769 {
770 struct dev_mc_list *mclist;
771 int i;
772 u8 *work8 = (u8 *)work32;
773
774 dprintk(KERN_INFO "i2o_lan: Enabling multicast mode...\n");
775 filter_mask = 0x00000004;
776
777 /* Fill the multicast addresses */
778 mclist = dev->mc_list;
779
780 for (i = 0; i < dev->mc_count; i++)
781 {
782 memcpy(work8, mclist->dmi_addr, mclist->dmi_addrlen);
783 work8 += 8;
784 mclist = mclist->next;
785 }
786
787 if (i2o_clear_table(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0002,
788 &priv->reply_flag) < 0 )
789 dprintk("%s: Unable to clear LAN_MULTICAST_MAC_ADDRESS table.\n",dev->name);
790
791 if (i2o_row_add_table(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0002, -1,
792 work32, dev->mc_count*8, &priv->reply_flag) < 0)
793 dprintk("%s: Unable to set LAN_MULTICAST_MAC_ADDRESS table.\n",dev->name);
794 }
795
796 else {
797 filter_mask |= 0x00000300; // Broadcast, Multicast disabled
798 dprintk(KERN_INFO "i2o_lan: Enabling unicast mode...\n");
799 }
800
801 if (i2o_set_scalar(iop, i2o_dev->id, priv->unit << 16 | lan_context, 0x0001, 3,
802 &filter_mask, 4, &priv->reply_flag) <0)
803 printk(KERN_WARNING "i2o_lan: Unable to set MAC FilterMask.\n");
804
805 return;
806 }
807
808 struct net_device *i2o_lan_register_device(struct i2o_device *i2o_dev)
809 {
810 struct net_device *dev = NULL;
811 struct i2o_lan_local *priv = NULL;
812 u8 hw_addr[8];
813 unsigned short (*type_trans)(struct sk_buff *, struct net_device *);
814 void (*unregister_dev)(struct net_device *dev);
815
816 switch (i2o_dev->subclass)
817 {
818 case I2O_LAN_ETHERNET:
819 dev = init_etherdev(NULL, sizeof(struct i2o_lan_local));
820 if (dev == NULL)
821 return NULL;
822 type_trans = eth_type_trans;
823 unregister_dev = unregister_netdev;
824 break;
825
826
827 #ifdef CONFIG_ANYLAN
828 case I2O_LAN_100VG:
829 printk(KERN_ERR "i2o_lan: 100base VG not yet supported\n");
830 break;
831 #endif
832
833
834 #ifdef CONFIG_TR
835 case I2O_LAN_TR:
836 dev = init_trdev(NULL, sizeof(struct i2o_lan_local));
837 if (dev==NULL)
838 return NULL;
839 type_trans = tr_type_trans;
840 unregister_dev = unregister_trdev;
841 break;
842 #endif
843
844 #ifdef CONFIG_FDDI
845 case I2O_LAN_FDDI:
846 {
847 int size = sizeof(struct net_device) + sizeof(struct i2o_lan_local)
848 + sizeof("fddi%d ");
849
850 dev = (struct net_device *) kmalloc(size, GFP_KERNEL);
851 memset((char *)dev, 0, size);
852 dev->priv = (void *)(dev + 1);
853 dev->name = (char *)(dev + 1) + sizeof(struct i2o_lan_local);
854
855 if (dev_alloc_name(dev,"fddi%d") < 0)
856 {
857 printk(KERN_WARNING "i2o_lan: Too many FDDI devices.\n");
858 kfree(dev);
859 return NULL;
860 }
861 type_trans = fddi_type_trans;
862 unregister_dev = (void *)unregister_netdevice;
863
864 fddi_setup(dev);
865 register_netdev(dev);
866 }
867 break;
868 #endif
869
870 #ifdef CONFIG_FIBRE_CHANNEL
871 case I2O_LAN_FIBRE_CHANNEL:
872 printk(KERN_INFO "i2o_lan: Fibre Channel not yet supported\n");
873 break;
874 #endif
875
876 case I2O_LAN_UNKNOWN:
877 default:
878 printk(KERN_ERR "i2o_lan: LAN type 0x%08X not supported\n",
879 i2o_dev->subclass);
880 return NULL;
881 }
882
883 priv = (struct i2o_lan_local *)dev->priv;
884 priv->i2o_dev = i2o_dev;
885 priv->type_trans = type_trans;
886 priv->bucket_count = 0;
887
888 unit++;
889 i2o_landevs[unit] = dev;
890 priv->unit = unit;
891
892 if (i2o_query_scalar(i2o_dev->controller, i2o_dev->id,
893 priv->unit << 16 | lan_context,
894 0x0001, 0, &hw_addr, 8, &priv->reply_flag) < 0)
895 {
896 printk(KERN_ERR "%s: Unable to query hardware address.\n", dev->name);
897 unit--;
898 unregister_dev(dev);
899 kfree(dev);
900 return NULL;
901 }
902
903 dprintk("%s: hwaddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
904 dev->name,hw_addr[0], hw_addr[1], hw_addr[2], hw_addr[3],
905 hw_addr[4], hw_addr[5]);
906
907 dev->addr_len = 6;
908 memcpy(dev->dev_addr, hw_addr, 6);
909
910 dev->open = i2o_lan_open;
911 dev->stop = i2o_lan_close;
912 dev->hard_start_xmit = i2o_lan_packet_send;
913 dev->get_stats = i2o_lan_get_stats;
914 dev->set_multicast_list = i2o_lan_set_multicast_list;
915
916 return dev;
917 }
918
919 #ifdef MODULE
920 #define i2o_lan_init init_module
921 #endif
922
923 __init int i2o_lan_init(void)
924 {
925 struct net_device *dev;
926 int i;
927
928 bucketpost = bucketpost - bucketthresh;
929
930 if (i2o_install_handler(&i2o_lan_handler) < 0)
931 {
932 printk(KERN_ERR "Unable to register I2O LAN OSM.\n");
933 return -EINVAL;
934 }
935
936 for(i=0; i <= MAX_LAN_CARDS; i++)
937 i2o_landevs[i] = NULL;
938
939 lan_context = i2o_lan_handler.context;
940
941 for (i=0; i < MAX_I2O_CONTROLLERS; i++)
942 {
943 struct i2o_controller *iop = i2o_find_controller(i);
944 struct i2o_device *i2o_dev;
945
946 if (iop==NULL)
947 continue;
948
949 for (i2o_dev=iop->devices;i2o_dev != NULL;i2o_dev=i2o_dev->next)
950 {
951 if (i2o_dev->class != I2O_CLASS_LAN)
952 continue;
953
954 if (unit == MAX_LAN_CARDS)
955 {
956 i2o_unlock_controller(iop);
957 printk(KERN_WARNING "Too many I2O LAN devices.\n");
958 return -EINVAL;
959 }
960
961 dev = i2o_lan_register_device(i2o_dev);
962 if (dev == NULL)
963 {
964 printk(KERN_ERR "Unable to register I2O LAN device\n");
965 continue; // try next one
966 }
967
968 printk(KERN_INFO "%s: I2O LAN device registered, tid = %d,"
969 " subclass = 0x%08X, unit = %d.\n",
970 dev->name, i2o_dev->id, i2o_dev->subclass,
971 ((struct i2o_lan_local *)dev->priv)->unit);
972 }
973
974 i2o_unlock_controller(iop);
975 }
976
977 dprintk(KERN_INFO "%d I2O LAN devices found and registered.\n", unit+1);
978
979 return 0;
980 }
981
982 #ifdef MODULE
983
984 void cleanup_module(void)
985 {
986 int i;
987
988 for (i = 0; i <= unit; i++)
989 {
990 struct net_device *dev = i2o_landevs[i];
991 struct i2o_lan_local *priv = (struct i2o_lan_local *)dev->priv;
992 struct i2o_device *i2o_dev = priv->i2o_dev;
993
994 switch (i2o_dev->subclass)
995 {
996 case I2O_LAN_ETHERNET:
997 unregister_netdev(dev);
998 kfree(dev);
999 break;
1000 #ifdef CONFIG_FDDI
1001 case I2O_LAN_FDDI:
1002 unregister_netdevice(dev);
1003 kfree(dev);
1004 break;
1005 #endif
1006 #ifdef CONFIG_TR
1007 case I2O_LAN_TR:
1008 unregister_trdev(dev);
1009 kfree(dev);
1010 break;
1011 #endif
1012 default:
1013 printk(KERN_WARNING "i2o_lan: Spurious I2O LAN subclass 0x%08X.\n",
1014 i2o_dev->subclass);
1015 }
1016
1017 dprintk(KERN_INFO "%s: I2O LAN device unregistered.\n",
1018 dev->name);
1019 }
1020
1021 i2o_remove_handler(&i2o_lan_handler);
1022 }
1023
1024 EXPORT_NO_SYMBOLS;
1025
1026 MODULE_AUTHOR("Univ of Helsinki, CS Department");
1027 MODULE_DESCRIPTION("I2O Lan OSM");
1028
1029 MODULE_PARM(bucketpost, "i"); // Number of buckets to post
1030 MODULE_PARM(bucketthresh, "i"); // Bucket post threshold
1031 MODULE_PARM(rx_copybreak, "i");
1032
1033 #endif
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux