ia64/linux-2.6.18-xen.hg

view drivers/net/atari_pamsnet.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /* atari_pamsnet.c PAMsNet device driver for linux68k.
2 *
3 * Version: @(#)PAMsNet.c 0.2 03/31/96
4 *
5 * Author: Torsten Lang <Torsten.Lang@ap.physik.uni-giessen.de>
6 * <Torsten.Lang@jung.de>
7 *
8 * This driver is based on my driver PAMSDMA.c for MiNT-Net and
9 * on the driver bionet.c written by
10 * Hartmut Laue <laue@ifk-mp.uni-kiel.de>
11 * and Torsten Narjes <narjes@ifk-mp.uni-kiel.de>
12 *
13 * Little adaptions for integration into pl7 by Roman Hodek
14 *
15 What is it ?
16 ------------
17 This driver controls the PAMsNet LAN-Adapter which connects
18 an ATARI ST/TT via the ACSI-port to an Ethernet-based network.
20 This version can be compiled as a loadable module (See the
21 compile command at the bottom of this file).
22 At load time, you can optionally set the debugging level and the
23 fastest response time on the command line of 'insmod'.
25 'pamsnet_debug'
26 controls the amount of diagnostic messages:
27 0 : no messages
28 >0 : see code for meaning of printed messages
30 'pamsnet_min_poll_time' (always >=1)
31 gives the time (in jiffies) between polls. Low values
32 increase the system load (beware!)
34 When loaded, a net device with the name 'eth?' becomes available,
35 which can be controlled with the usual 'ifconfig' command.
37 It is possible to compile this driver into the kernel like other
38 (net) drivers. For this purpose, some source files (e.g. config-files
39 makefiles, Space.c) must be changed accordingly. (You may refer to
40 other drivers how to do it.) In this case, the device will be detected
41 at boot time and (probably) appear as 'eth0'.
43 Theory of Operation
44 -------------------
45 Because the ATARI DMA port is usually shared between several
46 devices (eg. harddisk, floppy) we cannot block the ACSI bus
47 while waiting for interrupts. Therefore we use a polling mechanism
48 to fetch packets from the adapter. For the same reason, we send
49 packets without checking that the previous packet has been sent to
50 the LAN. We rely on the higher levels of the networking code to detect
51 missing packets and resend them.
53 Before we access the ATARI DMA controller, we check if another
54 process is using the DMA. If not, we lock the DMA, perform one or
55 more packet transfers and unlock the DMA before returning.
56 We do not use 'stdma_lock' unconditionally because it is unclear
57 if the networking code can be set to sleep, which will happen if
58 another (possibly slow) device is using the DMA controller.
60 The polling is done via timer interrupts which periodically
61 'simulate' an interrupt from the Ethernet adapter. The time (in jiffies)
62 between polls varies depending on an estimate of the net activity.
63 The allowed range is given by the variable 'bionet_min_poll_time'
64 for the lower (fastest) limit and the constant 'MAX_POLL_TIME'
65 for the higher (slowest) limit.
67 Whenever a packet arrives, we switch to fastest response by setting
68 the polling time to its lowest limit. If the following poll fails,
69 because no packets have arrived, we increase the time for the next
70 poll. When the net activity is low, the polling time effectively
71 stays at its maximum value, resulting in the lowest load for the
72 machine.
73 */
75 #define MAX_POLL_TIME 10
77 static char *version =
78 "pamsnet.c:v0.2beta 30-mar-96 (c) Torsten Lang.\n";
80 #include <linux/module.h>
82 #include <linux/kernel.h>
83 #include <linux/jiffies.h>
84 #include <linux/types.h>
85 #include <linux/fcntl.h>
86 #include <linux/interrupt.h>
87 #include <linux/ioport.h>
88 #include <linux/in.h>
89 #include <linux/slab.h>
90 #include <linux/string.h>
91 #include <linux/bitops.h>
92 #include <asm/system.h>
93 #include <asm/pgtable.h>
94 #include <asm/io.h>
95 #include <asm/dma.h>
96 #include <linux/errno.h>
97 #include <asm/atarihw.h>
98 #include <asm/atariints.h>
99 #include <asm/atari_stdma.h>
100 #include <asm/atari_acsi.h>
102 #include <linux/delay.h>
103 #include <linux/timer.h>
104 #include <linux/init.h>
106 #include <linux/netdevice.h>
107 #include <linux/etherdevice.h>
108 #include <linux/skbuff.h>
110 #undef READ
111 #undef WRITE
113 /* use 0 for production, 1 for verification, >2 for debug
114 */
115 #ifndef NET_DEBUG
116 #define NET_DEBUG 0
117 #endif
118 /*
119 * Global variable 'pamsnet_debug'. Can be set at load time by 'insmod'
120 */
121 unsigned int pamsnet_debug = NET_DEBUG;
122 module_param(pamsnet_debug, int, 0);
123 MODULE_PARM_DESC(pamsnet_debug, "pamsnet debug enable (0-1)");
124 MODULE_LICENSE("GPL");
126 static unsigned int pamsnet_min_poll_time = 2;
129 /* Information that need to be kept for each board.
130 */
131 struct net_local {
132 struct net_device_stats stats;
133 long open_time; /* for debugging */
134 int poll_time; /* polling time varies with net load */
135 };
137 static struct nic_pkt_s { /* packet format */
138 unsigned char buffer[2048];
139 } *nic_packet = 0;
140 unsigned char *phys_nic_packet;
142 typedef unsigned char HADDR[6]; /* 6-byte hardware address of lance */
144 /* Index to functions, as function prototypes.
145 */
146 static void start (int target);
147 static int stop (int target);
148 static int testpkt (int target);
149 static int sendpkt (int target, unsigned char *buffer, int length);
150 static int receivepkt (int target, unsigned char *buffer);
151 static int inquiry (int target, unsigned char *buffer);
152 static HADDR *read_hw_addr(int target, unsigned char *buffer);
153 static void setup_dma (void *address, unsigned rw_flag, int num_blocks);
154 static int send_first (int target, unsigned char byte);
155 static int send_1_5 (int lun, unsigned char *command, int dma);
156 static int get_status (void);
157 static int calc_received (void *start_address);
159 static int pamsnet_open(struct net_device *dev);
160 static int pamsnet_send_packet(struct sk_buff *skb, struct net_device *dev);
161 static void pamsnet_poll_rx(struct net_device *);
162 static int pamsnet_close(struct net_device *dev);
163 static struct net_device_stats *net_get_stats(struct net_device *dev);
164 static void pamsnet_tick(unsigned long);
166 static irqreturn_t pamsnet_intr(int irq, void *data, struct pt_regs *fp);
168 static DEFINE_TIMER(pamsnet_timer, pamsnet_tick, 0, 0);
170 #define STRAM_ADDR(a) (((a) & 0xff000000) == 0)
172 typedef struct
173 {
174 unsigned char reserved1[0x38];
175 HADDR hwaddr;
176 unsigned char reserved2[0x1c2];
177 } DMAHWADDR;
179 /*
180 * Definitions of commands understood by the PAMs DMA adaptor.
181 *
182 * In general the DMA adaptor uses LUN 0, 5, 6 and 7 on one ID changeable
183 * by the PAM's Net software.
184 *
185 * LUN 0 works as a harddisk. You can boot the PAM's Net driver there.
186 * LUN 5 works as a harddisk and lets you access the RAM and some I/O HW
187 * area. In sector 0, bytes 0x38-0x3d you find the ethernet HW address
188 * of the adaptor.
189 * LUN 6 works as a harddisk and lets you access the firmware ROM.
190 * LUN 7 lets you send and receive packets.
191 *
192 * Some commands like the INQUIRY command work identical on all used LUNs.
193 *
194 * UNKNOWN1 seems to read some data.
195 * Command length is 6 bytes.
196 * UNKNOWN2 seems to read some data (command byte 1 must be !=0). The
197 * following bytes seem to be something like an allocation length.
198 * Command length is 6 bytes.
199 * READPKT reads a packet received by the DMA adaptor.
200 * Command length is 6 bytes.
201 * WRITEPKT sends a packet transferred by the following DMA phase. The length
202 * of the packet is transferred in command bytes 3 and 4.
203 * The adaptor automatically replaces the src hw address in an ethernet
204 * packet by its own hw address.
205 * Command length is 6 bytes.
206 * INQUIRY has the same function as the INQUIRY command supported by harddisks
207 * and other SCSI devices. It lets you detect which device you found
208 * at a given address.
209 * Command length is 6 bytes.
210 * START initializes the DMA adaptor. After this command it is able to send
211 * and receive packets. There is no status byte returned!
212 * Command length is 1 byte.
213 * NUMPKTS gives back the number of received packets waiting in the queue in
214 * the status byte.
215 * Command length is 1 byte.
216 * UNKNOWN3
217 * UNKNOWN4 Function of these three commands is unknown.
218 * UNKNOWN5 The command length of these three commands is 1 byte.
219 * DESELECT immediately deselects the DMA adaptor. May important with interrupt
220 * driven operation.
221 * Command length is 1 byte.
222 * STOP resets the DMA adaptor. After this command packets can no longer
223 * be received or transferred.
224 * Command length is 6 byte.
225 */
227 enum {UNKNOWN1=3, READPKT=8, UNKNOWN2, WRITEPKT=10, INQUIRY=18, START,
228 NUMPKTS=22, UNKNOWN3, UNKNOWN4, UNKNOWN5, DESELECT, STOP};
230 #define READSECTOR READPKT
231 #define WRITESECTOR WRITEPKT
233 u_char *inquire8="MV PAM's NET/GK";
235 #define DMALOW dma_wd.dma_lo
236 #define DMAMID dma_wd.dma_md
237 #define DMAHIGH dma_wd.dma_hi
238 #define DACCESS dma_wd.fdc_acces_seccount
240 #define MFP_GPIP mfp.par_dt_reg
242 /* Some useful functions */
244 #define INT (!(MFP_GPIP & 0x20))
245 #define DELAY ({MFP_GPIP; MFP_GPIP; MFP_GPIP;})
246 #define WRITEMODE(value) \
247 ({ u_short dummy = value; \
248 __asm__ volatile("movew %0, 0xFFFF8606" : : "d"(dummy)); \
249 DELAY; \
250 })
251 #define WRITEBOTH(value1, value2) \
252 ({ u_long dummy = (u_long)(value1)<<16 | (u_short)(value2); \
253 __asm__ volatile("movel %0, 0xFFFF8604" : : "d"(dummy)); \
254 DELAY; \
255 })
257 /* Definitions for DMODE */
259 #define READ 0x000
260 #define WRITE 0x100
262 #define DMA_FDC 0x080
263 #define DMA_ACSI 0x000
265 #define DMA_DISABLE 0x040
267 #define SEC_COUNT 0x010
268 #define DMA_WINDOW 0x000
270 #define REG_ACSI 0x008
271 #define REG_FDC 0x000
273 #define A1 0x002
275 /* Timeout constants */
277 #define TIMEOUTCMD HZ/2 /* ca. 500ms */
278 #define TIMEOUTDMA HZ /* ca. 1s */
279 #define COMMAND_DELAY 500 /* ca. 0.5ms */
281 unsigned rw;
282 int lance_target = -1;
283 int if_up = 0;
285 /* The following routines access the ethernet board connected to the
286 * ACSI port via the st_dma chip.
287 */
289 /* The following lowlevel routines work on physical addresses only and assume
290 * that eventually needed buffers are
291 * - completely located in ST RAM
292 * - are contigous in the physical address space
293 */
295 /* Setup the DMA counter */
297 static void
298 setup_dma (address, rw_flag, num_blocks)
299 void *address;
300 unsigned rw_flag;
301 int num_blocks;
302 {
303 WRITEMODE((unsigned) rw_flag | DMA_FDC | SEC_COUNT | REG_ACSI |
304 A1);
305 WRITEMODE((unsigned)(rw_flag ^ WRITE) | DMA_FDC | SEC_COUNT | REG_ACSI |
306 A1);
307 WRITEMODE((unsigned) rw_flag | DMA_FDC | SEC_COUNT | REG_ACSI |
308 A1);
309 DMALOW = (unsigned char)((unsigned long)address & 0xFF);
310 DMAMID = (unsigned char)(((unsigned long)address >> 8) & 0xFF);
311 DMAHIGH = (unsigned char)(((unsigned long)address >> 16) & 0xFF);
312 WRITEBOTH((unsigned)num_blocks & 0xFF,
313 rw_flag | DMA_FDC | DMA_WINDOW | REG_ACSI | A1);
314 rw = rw_flag;
315 }
317 /* Send the first byte of an command block */
319 static int
320 send_first (target, byte)
321 int target;
322 unsigned char byte;
323 {
324 rw = READ;
325 acsi_delay_end(COMMAND_DELAY);
326 /*
327 * wake up ACSI
328 */
329 WRITEMODE(DMA_FDC | DMA_WINDOW | REG_ACSI);
330 /*
331 * write command byte
332 */
333 WRITEBOTH((target << 5) | (byte & 0x1F), DMA_FDC |
334 DMA_WINDOW | REG_ACSI | A1);
335 return (!acsi_wait_for_IRQ(TIMEOUTCMD));
336 }
338 /* Send the rest of an command block */
340 static int
341 send_1_5 (lun, command, dma)
342 int lun;
343 unsigned char *command;
344 int dma;
345 {
346 int i, j;
348 for (i=0; i<5; i++) {
349 WRITEBOTH((!i ? (((lun & 0x7) << 5) | (command[i] & 0x1F))
350 : command[i]),
351 rw | REG_ACSI | DMA_WINDOW |
352 ((i < 4) ? DMA_FDC
353 : (dma ? DMA_ACSI
354 : DMA_FDC)) | A1);
355 if (i < 4 && (j = !acsi_wait_for_IRQ(TIMEOUTCMD)))
356 return (j);
357 }
358 return (0);
359 }
361 /* Read a status byte */
363 static int
364 get_status (void)
365 {
366 WRITEMODE(DMA_FDC | DMA_WINDOW | REG_ACSI | A1);
367 acsi_delay_start();
368 return ((int)(DACCESS & 0xFF));
369 }
371 /* Calculate the number of received bytes */
373 static int
374 calc_received (start_address)
375 void *start_address;
376 {
377 return (int)(
378 (((unsigned long)DMAHIGH << 16) | ((unsigned)DMAMID << 8) | DMALOW)
379 - (unsigned long)start_address);
380 }
382 /* The following midlevel routines still work on physical addresses ... */
384 /* start() starts the PAM's DMA adaptor */
386 static void
387 start (target)
388 int target;
389 {
390 send_first(target, START);
391 }
393 /* stop() stops the PAM's DMA adaptor and returns a value of zero in case of success */
395 static int
396 stop (target)
397 int target;
398 {
399 int ret = -1;
400 unsigned char cmd_buffer[5];
402 if (send_first(target, STOP))
403 goto bad;
404 cmd_buffer[0] = cmd_buffer[1] = cmd_buffer[2] =
405 cmd_buffer[3] = cmd_buffer[4] = 0;
406 if (send_1_5(7, cmd_buffer, 0) ||
407 !acsi_wait_for_IRQ(TIMEOUTDMA) ||
408 get_status())
409 goto bad;
410 ret = 0;
411 bad:
412 return (ret);
413 }
415 /* testpkt() returns the number of received packets waiting in the queue */
417 static int
418 testpkt(target)
419 int target;
420 {
421 int ret = -1;
423 if (send_first(target, NUMPKTS))
424 goto bad;
425 ret = get_status();
426 bad:
427 return (ret);
428 }
430 /* inquiry() returns 0 when PAM's DMA found, -1 when timeout, -2 otherwise */
431 /* Please note: The buffer is for internal use only but must be defined! */
433 static int
434 inquiry (target, buffer)
435 int target;
436 unsigned char *buffer;
437 {
438 int ret = -1;
439 unsigned char *vbuffer = phys_to_virt((unsigned long)buffer);
440 unsigned char cmd_buffer[5];
442 if (send_first(target, INQUIRY))
443 goto bad;
444 setup_dma(buffer, READ, 1);
445 vbuffer[8] = vbuffer[27] = 0; /* Avoid confusion with previous read data */
446 cmd_buffer[0] = cmd_buffer[1] = cmd_buffer[2] = cmd_buffer[4] = 0;
447 cmd_buffer[3] = 48;
448 if (send_1_5(5, cmd_buffer, 1) ||
449 !acsi_wait_for_IRQ(TIMEOUTDMA) ||
450 get_status() ||
451 (calc_received(buffer) < 32))
452 goto bad;
453 dma_cache_maintenance((unsigned long)(buffer+8), 20, 0);
454 if (memcmp(inquire8, vbuffer+8, 20))
455 goto bad;
456 ret = 0;
457 bad:
458 if (!!NET_DEBUG) {
459 vbuffer[8+20]=0;
460 printk("inquiry of target %d: %s\n", target, vbuffer+8);
461 }
462 return (ret);
463 }
465 /*
466 * read_hw_addr() reads the sector containing the hwaddr and returns
467 * a pointer to it (virtual address!) or 0 in case of an error
468 */
470 static HADDR
471 *read_hw_addr(target, buffer)
472 int target;
473 unsigned char *buffer;
474 {
475 HADDR *ret = 0;
476 unsigned char cmd_buffer[5];
478 if (send_first(target, READSECTOR))
479 goto bad;
480 setup_dma(buffer, READ, 1);
481 cmd_buffer[0] = cmd_buffer[1] = cmd_buffer[2] = cmd_buffer[4] = 0;
482 cmd_buffer[3] = 1;
483 if (send_1_5(5, cmd_buffer, 1) ||
484 !acsi_wait_for_IRQ(TIMEOUTDMA) ||
485 get_status())
486 goto bad;
487 ret = phys_to_virt((unsigned long)&(((DMAHWADDR *)buffer)->hwaddr));
488 dma_cache_maintenance((unsigned long)buffer, 512, 0);
489 bad:
490 return (ret);
491 }
493 static irqreturn_t
494 pamsnet_intr(irq, data, fp)
495 int irq;
496 void *data;
497 struct pt_regs *fp;
498 {
499 return IRQ_HANDLED;
500 }
502 /* receivepkt() loads a packet to a given buffer and returns its length */
504 static int
505 receivepkt (target, buffer)
506 int target;
507 unsigned char *buffer;
508 {
509 int ret = -1;
510 unsigned char cmd_buffer[5];
512 if (send_first(target, READPKT))
513 goto bad;
514 setup_dma(buffer, READ, 3);
515 cmd_buffer[0] = cmd_buffer[1] = cmd_buffer[2] = cmd_buffer[4] = 0;
516 cmd_buffer[3] = 3;
517 if (send_1_5(7, cmd_buffer, 1) ||
518 !acsi_wait_for_IRQ(TIMEOUTDMA) ||
519 get_status())
520 goto bad;
521 ret = calc_received(buffer);
522 bad:
523 return (ret);
524 }
526 /* sendpkt() sends a packet and returns a value of zero when the packet was sent
527 successfully */
529 static int
530 sendpkt (target, buffer, length)
531 int target;
532 unsigned char *buffer;
533 int length;
534 {
535 int ret = -1;
536 unsigned char cmd_buffer[5];
538 if (send_first(target, WRITEPKT))
539 goto bad;
540 setup_dma(buffer, WRITE, 3);
541 cmd_buffer[0] = cmd_buffer[1] = cmd_buffer[4] = 0;
542 cmd_buffer[2] = length >> 8;
543 cmd_buffer[3] = length & 0xFF;
544 if (send_1_5(7, cmd_buffer, 1) ||
545 !acsi_wait_for_IRQ(TIMEOUTDMA) ||
546 get_status())
547 goto bad;
548 ret = 0;
549 bad:
550 return (ret);
551 }
553 /* The following higher level routines work on virtual addresses and convert them to
554 * physical addresses when passed to the lowlevel routines. It's up to the higher level
555 * routines to copy data from Alternate RAM to ST RAM if neccesary!
556 */
558 /* Check for a network adaptor of this type, and return '0' if one exists.
559 */
561 struct net_device * __init pamsnet_probe (int unit)
562 {
563 struct net_device *dev;
564 int i;
565 HADDR *hwaddr;
566 int err;
568 unsigned char station_addr[6];
569 static unsigned version_printed;
570 /* avoid "Probing for..." printed 4 times - the driver is supporting only one adapter now! */
571 static int no_more_found;
573 if (no_more_found)
574 return ERR_PTR(-ENODEV);
575 no_more_found = 1;
577 dev = alloc_etherdev(sizeof(struct net_local));
578 if (!dev)
579 return ERR_PTR(-ENOMEM);
580 if (unit >= 0) {
581 sprintf(dev->name, "eth%d", unit);
582 netdev_boot_setup_check(dev);
583 }
584 SET_MODULE_OWNER(dev);
586 printk("Probing for PAM's Net/GK Adapter...\n");
588 /* Allocate the DMA buffer here since we need it for probing! */
590 nic_packet = (struct nic_pkt_s *)acsi_buffer;
591 phys_nic_packet = (unsigned char *)phys_acsi_buffer;
592 if (pamsnet_debug > 0) {
593 printk("nic_packet at 0x%p, phys at 0x%p\n",
594 nic_packet, phys_nic_packet );
595 }
597 stdma_lock(pamsnet_intr, NULL);
598 DISABLE_IRQ();
600 for (i=0; i<8; i++) {
601 /* Do two inquiries to cover cases with strange equipment on previous ID */
602 /* blocking the ACSI bus (like the SLMC804 laser printer controller... */
603 inquiry(i, phys_nic_packet);
604 if (!inquiry(i, phys_nic_packet)) {
605 lance_target = i;
606 break;
607 }
608 }
610 if (!!NET_DEBUG)
611 printk("ID: %d\n",i);
613 if (lance_target >= 0) {
614 if (!(hwaddr = read_hw_addr(lance_target, phys_nic_packet)))
615 lance_target = -1;
616 else
617 memcpy (station_addr, hwaddr, ETH_ALEN);
618 }
620 ENABLE_IRQ();
621 stdma_release();
623 if (lance_target < 0) {
624 printk("No PAM's Net/GK found.\n");
625 free_netdev(dev);
626 return ERR_PTR(-ENODEV);
627 }
629 if (pamsnet_debug > 0 && version_printed++ == 0)
630 printk(version);
632 printk("%s: %s found on target %01d, eth-addr: %02x:%02x:%02x:%02x:%02x:%02x.\n",
633 dev->name, "PAM's Net/GK", lance_target,
634 station_addr[0], station_addr[1], station_addr[2],
635 station_addr[3], station_addr[4], station_addr[5]);
637 /* Initialize the device structure. */
638 dev->open = pamsnet_open;
639 dev->stop = pamsnet_close;
640 dev->hard_start_xmit = pamsnet_send_packet;
641 dev->get_stats = net_get_stats;
643 /* Fill in the fields of the device structure with ethernet-generic
644 * values. This should be in a common file instead of per-driver.
645 */
647 for (i = 0; i < ETH_ALEN; i++) {
648 #if 0
649 dev->broadcast[i] = 0xff;
650 #endif
651 dev->dev_addr[i] = station_addr[i];
652 }
653 err = register_netdev(dev);
654 if (!err)
655 return dev;
657 free_netdev(dev);
658 return ERR_PTR(err);
659 }
661 /* Open/initialize the board. This is called (in the current kernel)
662 sometime after booting when the 'ifconfig' program is run.
664 This routine should set everything up anew at each open, even
665 registers that "should" only need to be set once at boot, so that
666 there is non-reboot way to recover if something goes wrong.
667 */
668 static int
669 pamsnet_open(struct net_device *dev) {
670 struct net_local *lp = netdev_priv(dev);
672 if (pamsnet_debug > 0)
673 printk("pamsnet_open\n");
674 stdma_lock(pamsnet_intr, NULL);
675 DISABLE_IRQ();
677 /* Reset the hardware here.
678 */
679 if (!if_up)
680 start(lance_target);
681 if_up = 1;
682 lp->open_time = 0; /*jiffies*/
683 lp->poll_time = MAX_POLL_TIME;
685 dev->tbusy = 0;
686 dev->interrupt = 0;
687 dev->start = 1;
689 ENABLE_IRQ();
690 stdma_release();
691 pamsnet_timer.data = (long)dev;
692 pamsnet_timer.expires = jiffies + lp->poll_time;
693 add_timer(&pamsnet_timer);
694 return 0;
695 }
697 static int
698 pamsnet_send_packet(struct sk_buff *skb, struct net_device *dev) {
699 struct net_local *lp = netdev_priv(dev);
700 unsigned long flags;
702 /* Block a timer-based transmit from overlapping. This could better be
703 * done with atomic_swap(1, dev->tbusy), but set_bit() works as well.
704 */
705 local_irq_save(flags);
707 if (stdma_islocked()) {
708 local_irq_restore(flags);
709 lp->stats.tx_errors++;
710 }
711 else {
712 int length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
713 unsigned long buf = virt_to_phys(skb->data);
714 int stat;
716 stdma_lock(pamsnet_intr, NULL);
717 DISABLE_IRQ();
719 local_irq_restore(flags);
720 if( !STRAM_ADDR(buf+length-1) ) {
721 memcpy(nic_packet->buffer, skb->data, length);
722 buf = (unsigned long)phys_nic_packet;
723 }
725 dma_cache_maintenance(buf, length, 1);
727 stat = sendpkt(lance_target, (unsigned char *)buf, length);
728 ENABLE_IRQ();
729 stdma_release();
731 dev->trans_start = jiffies;
732 dev->tbusy = 0;
733 lp->stats.tx_packets++;
734 lp->stats.tx_bytes+=length;
735 }
736 dev_kfree_skb(skb);
738 return 0;
739 }
741 /* We have a good packet(s), get it/them out of the buffers.
742 */
743 static void
744 pamsnet_poll_rx(struct net_device *dev) {
745 struct net_local *lp = netdev_priv(dev);
746 int boguscount;
747 int pkt_len;
748 struct sk_buff *skb;
749 unsigned long flags;
751 local_irq_save(flags);
752 /* ++roman: Take care at locking the ST-DMA... This must be done with ints
753 * off, since otherwise an int could slip in between the question and the
754 * locking itself, and then we'd go to sleep... And locking itself is
755 * necessary to keep the floppy_change timer from working with ST-DMA
756 * registers. */
757 if (stdma_islocked()) {
758 local_irq_restore(flags);
759 return;
760 }
761 stdma_lock(pamsnet_intr, NULL);
762 DISABLE_IRQ();
763 local_irq_restore(flags);
765 boguscount = testpkt(lance_target);
766 if( lp->poll_time < MAX_POLL_TIME ) lp->poll_time++;
768 while(boguscount--) {
769 pkt_len = receivepkt(lance_target, phys_nic_packet);
771 if( pkt_len < 60 ) break;
773 /* Good packet... */
775 dma_cache_maintenance((unsigned long)phys_nic_packet, pkt_len, 0);
777 lp->poll_time = pamsnet_min_poll_time; /* fast poll */
778 if( pkt_len >= 60 && pkt_len <= 2048 ) {
779 if (pkt_len > 1514)
780 pkt_len = 1514;
782 /* Malloc up new buffer.
783 */
784 skb = alloc_skb(pkt_len, GFP_ATOMIC);
785 if (skb == NULL) {
786 printk("%s: Memory squeeze, dropping packet.\n",
787 dev->name);
788 lp->stats.rx_dropped++;
789 break;
790 }
791 skb->len = pkt_len;
792 skb->dev = dev;
794 /* 'skb->data' points to the start of sk_buff data area.
795 */
796 memcpy(skb->data, nic_packet->buffer, pkt_len);
797 netif_rx(skb);
798 dev->last_rx = jiffies;
799 lp->stats.rx_packets++;
800 lp->stats.rx_bytes+=pkt_len;
801 }
802 }
804 /* If any worth-while packets have been received, dev_rint()
805 has done a mark_bh(INET_BH) for us and will work on them
806 when we get to the bottom-half routine.
807 */
809 ENABLE_IRQ();
810 stdma_release();
811 return;
812 }
814 /* pamsnet_tick: called by pamsnet_timer. Reads packets from the adapter,
815 * passes them to the higher layers and restarts the timer.
816 */
817 static void
818 pamsnet_tick(unsigned long data) {
819 struct net_device *dev = (struct net_device *)data;
820 struct net_local *lp = netdev_priv(dev);
822 if( pamsnet_debug > 0 && (lp->open_time++ & 7) == 8 )
823 printk("pamsnet_tick: %ld\n", lp->open_time);
825 pamsnet_poll_rx(dev);
827 pamsnet_timer.expires = jiffies + lp->poll_time;
828 add_timer(&pamsnet_timer);
829 }
831 /* The inverse routine to pamsnet_open().
832 */
833 static int
834 pamsnet_close(struct net_device *dev) {
835 struct net_local *lp = netdev_priv(dev);
837 if (pamsnet_debug > 0)
838 printk("pamsnet_close, open_time=%ld\n", lp->open_time);
839 del_timer(&pamsnet_timer);
840 stdma_lock(pamsnet_intr, NULL);
841 DISABLE_IRQ();
843 if (if_up)
844 stop(lance_target);
845 if_up = 0;
847 lp->open_time = 0;
849 dev->tbusy = 1;
850 dev->start = 0;
852 ENABLE_IRQ();
853 stdma_release();
854 return 0;
855 }
857 /* Get the current statistics.
858 This may be called with the card open or closed.
859 */
860 static struct net_device_stats *net_get_stats(struct net_device *dev)
861 {
862 struct net_local *lp = netdev_priv(dev);
863 return &lp->stats;
864 }
867 #ifdef MODULE
869 static struct net_device *pam_dev;
871 int init_module(void)
872 {
873 pam_dev = pamsnet_probe(-1);
874 if (IS_ERR(pam_dev))
875 return PTR_ERR(pam_dev);
876 return 0;
877 }
879 void cleanup_module(void)
880 {
881 unregister_netdev(pam_dev);
882 free_netdev(pam_dev);
883 }
885 #endif /* MODULE */
887 /* Local variables:
888 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/include
889 -b m68k-linuxaout -Wall -Wstrict-prototypes -O2
890 -fomit-frame-pointer -pipe -DMODULE -I../../net/inet -c atari_pamsnet.c"
891 * version-control: t
892 * kept-new-versions: 5
893 * tab-width: 8
894 * End:
895 */