[SK_BUFF]: Introduce skb_copy_from_linear_data{_offset}
[linux-3.10.git] / drivers / net / atari_pamsnet.c
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.
19
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'.
24
25         'pamsnet_debug'
26                 controls the amount of diagnostic messages:
27           0  : no messages
28           >0 : see code for meaning of printed messages
29
30         'pamsnet_min_poll_time' (always >=1)
31                 gives the time (in jiffies) between polls. Low values
32                 increase the system load (beware!)
33
34         When loaded, a net device with the name 'eth?' becomes available,
35         which can be controlled with the usual 'ifconfig' command.
36
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'.
42
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.
52
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.
59
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.
66
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  */
74
75 #define MAX_POLL_TIME   10
76
77 static char *version =
78         "pamsnet.c:v0.2beta 30-mar-96 (c) Torsten Lang.\n";
79
80 #include <linux/module.h>
81
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>
101
102 #include <linux/delay.h>
103 #include <linux/timer.h>
104 #include <linux/init.h>
105
106 #include <linux/netdevice.h>
107 #include <linux/etherdevice.h>
108 #include <linux/skbuff.h>
109
110 #undef READ
111 #undef WRITE
112
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");
125
126 static unsigned int pamsnet_min_poll_time = 2;
127
128
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 };
136
137 static struct nic_pkt_s {               /* packet format */
138         unsigned char   buffer[2048];
139 } *nic_packet = 0;
140 unsigned char *phys_nic_packet;
141
142 typedef unsigned char HADDR[6]; /* 6-byte hardware address of lance */
143
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);
158
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);
165
166 static irqreturn_t pamsnet_intr(int irq, void *data);
167
168 static DEFINE_TIMER(pamsnet_timer, pamsnet_tick, 0, 0);
169
170 #define STRAM_ADDR(a)   (((a) & 0xff000000) == 0)
171
172 typedef struct
173 {
174         unsigned char reserved1[0x38];
175         HADDR  hwaddr;
176         unsigned char reserved2[0x1c2];
177 } DMAHWADDR;
178
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  */
226
227 enum {UNKNOWN1=3, READPKT=8, UNKNOWN2, WRITEPKT=10, INQUIRY=18, START,
228       NUMPKTS=22, UNKNOWN3, UNKNOWN4, UNKNOWN5, DESELECT, STOP};
229
230 #define READSECTOR  READPKT
231 #define WRITESECTOR WRITEPKT
232
233 u_char *inquire8="MV      PAM's NET/GK";
234
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
239
240 #define MFP_GPIP mfp.par_dt_reg
241
242 /* Some useful functions */
243
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         })
256
257 /* Definitions for DMODE */
258
259 #define READ        0x000
260 #define WRITE       0x100
261
262 #define DMA_FDC     0x080
263 #define DMA_ACSI    0x000
264
265 #define DMA_DISABLE 0x040
266
267 #define SEC_COUNT   0x010
268 #define DMA_WINDOW  0x000
269
270 #define REG_ACSI    0x008
271 #define REG_FDC     0x000
272
273 #define A1          0x002
274
275 /* Timeout constants */
276
277 #define TIMEOUTCMD HZ/2   /* ca. 500ms */
278 #define TIMEOUTDMA HZ     /* ca. 1s */
279 #define COMMAND_DELAY 500 /* ca. 0.5ms */
280
281 unsigned rw;
282 int lance_target = -1;
283 int if_up = 0;
284
285 /* The following routines access the ethernet board connected to the
286  * ACSI port via the st_dma chip.
287  */
288
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  */
294
295 /* Setup the DMA counter */
296
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 }
316
317 /* Send the first byte of an command block */
318
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 }
337
338 /* Send the rest of an command block */
339
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;
347
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 }
360
361 /* Read a status byte */
362
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 }
370
371 /* Calculate the number of received bytes */
372
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 }
381
382 /* The following midlevel routines still work on physical addresses ... */
383
384 /* start() starts the PAM's DMA adaptor */
385
386 static void
387 start (target)
388         int target;
389 {
390         send_first(target, START);
391 }
392
393 /* stop() stops the PAM's DMA adaptor and returns a value of zero in case of success */
394
395 static int
396 stop (target)
397         int target;
398 {
399         int ret = -1;
400         unsigned char cmd_buffer[5];
401
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 }
414
415 /* testpkt() returns the number of received packets waiting in the queue */
416
417 static int
418 testpkt(target)
419         int target;
420 {
421         int ret = -1;
422
423         if (send_first(target, NUMPKTS))
424                 goto bad;
425         ret = get_status();
426 bad:
427         return (ret);
428 }
429
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!   */
432
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];
441
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 }
464
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  */
469
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];
477
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 }
492
493 static irqreturn_t
494 pamsnet_intr(irq, data, fp)
495         int irq;
496         void *data;
497 {
498         return IRQ_HANDLED;
499 }
500
501 /* receivepkt() loads a packet to a given buffer and returns its length */
502
503 static int
504 receivepkt (target, buffer)
505         int target;
506         unsigned char *buffer;
507 {
508         int ret = -1;
509         unsigned char cmd_buffer[5];
510
511         if (send_first(target, READPKT))
512                 goto bad;
513         setup_dma(buffer, READ, 3);
514         cmd_buffer[0] = cmd_buffer[1] = cmd_buffer[2] = cmd_buffer[4] = 0;
515         cmd_buffer[3] = 3;
516         if (send_1_5(7, cmd_buffer, 1) ||
517             !acsi_wait_for_IRQ(TIMEOUTDMA) ||
518             get_status())
519                 goto bad;
520         ret = calc_received(buffer);
521 bad:
522         return (ret);
523 }
524
525 /* sendpkt() sends a packet and returns a value of zero when the packet was sent
526              successfully */
527
528 static int
529 sendpkt (target, buffer, length)
530         int target;
531         unsigned char *buffer;
532         int length;
533 {
534         int ret = -1;
535         unsigned char cmd_buffer[5];
536
537         if (send_first(target, WRITEPKT))
538                 goto bad;
539         setup_dma(buffer, WRITE, 3);
540         cmd_buffer[0] = cmd_buffer[1] = cmd_buffer[4] = 0;
541         cmd_buffer[2] = length >> 8;
542         cmd_buffer[3] = length & 0xFF;
543         if (send_1_5(7, cmd_buffer, 1) ||
544             !acsi_wait_for_IRQ(TIMEOUTDMA) ||
545             get_status())
546                 goto bad;
547         ret = 0;
548 bad:
549         return (ret);
550 }
551
552 /* The following higher level routines work on virtual addresses and convert them to
553  * physical addresses when passed to the lowlevel routines. It's up to the higher level
554  * routines to copy data from Alternate RAM to ST RAM if neccesary!
555  */
556
557 /* Check for a network adaptor of this type, and return '0' if one exists.
558  */
559
560 struct net_device * __init pamsnet_probe (int unit)
561 {
562         struct net_device *dev;
563         int i;
564         HADDR *hwaddr;
565         int err;
566
567         unsigned char station_addr[6];
568         static unsigned version_printed;
569         /* avoid "Probing for..." printed 4 times - the driver is supporting only one adapter now! */
570         static int no_more_found;
571
572         if (no_more_found)
573                 return ERR_PTR(-ENODEV);
574         no_more_found = 1;
575
576         dev = alloc_etherdev(sizeof(struct net_local));
577         if (!dev)
578                 return ERR_PTR(-ENOMEM);
579         if (unit >= 0) {
580                 sprintf(dev->name, "eth%d", unit);
581                 netdev_boot_setup_check(dev);
582         }
583         SET_MODULE_OWNER(dev);
584
585         printk("Probing for PAM's Net/GK Adapter...\n");
586
587         /* Allocate the DMA buffer here since we need it for probing! */
588
589         nic_packet = (struct nic_pkt_s *)acsi_buffer;
590         phys_nic_packet = (unsigned char *)phys_acsi_buffer;
591         if (pamsnet_debug > 0) {
592                 printk("nic_packet at 0x%p, phys at 0x%p\n",
593                            nic_packet, phys_nic_packet );
594         }
595
596         stdma_lock(pamsnet_intr, NULL);
597         DISABLE_IRQ();
598
599         for (i=0; i<8; i++) {
600                 /* Do two inquiries to cover cases with strange equipment on previous ID */
601                 /* blocking the ACSI bus (like the SLMC804 laser printer controller...   */
602                 inquiry(i, phys_nic_packet);
603                 if (!inquiry(i, phys_nic_packet)) {
604                         lance_target = i;
605                         break;
606                 }
607         }
608
609         if (!!NET_DEBUG)
610                 printk("ID: %d\n",i);
611
612         if (lance_target >= 0) {
613                 if (!(hwaddr = read_hw_addr(lance_target, phys_nic_packet)))
614                         lance_target = -1;
615                 else
616                         memcpy (station_addr, hwaddr, ETH_ALEN);
617         }
618
619         ENABLE_IRQ();
620         stdma_release();
621
622         if (lance_target < 0) {
623                 printk("No PAM's Net/GK found.\n");
624                 free_netdev(dev);
625                 return ERR_PTR(-ENODEV);
626         }
627
628         if (pamsnet_debug > 0 && version_printed++ == 0)
629                 printk(version);
630
631         printk("%s: %s found on target %01d, eth-addr: %02x:%02x:%02x:%02x:%02x:%02x.\n",
632                 dev->name, "PAM's Net/GK", lance_target,
633                 station_addr[0], station_addr[1], station_addr[2],
634                 station_addr[3], station_addr[4], station_addr[5]);
635
636         /* Initialize the device structure. */
637         dev->open               = pamsnet_open;
638         dev->stop               = pamsnet_close;
639         dev->hard_start_xmit    = pamsnet_send_packet;
640         dev->get_stats          = net_get_stats;
641
642         /* Fill in the fields of the device structure with ethernet-generic
643          * values. This should be in a common file instead of per-driver.
644          */
645
646         for (i = 0; i < ETH_ALEN; i++) {
647 #if 0
648                 dev->broadcast[i] = 0xff;
649 #endif
650                 dev->dev_addr[i]  = station_addr[i];
651         }
652         err = register_netdev(dev);
653         if (!err)
654                 return dev;
655
656         free_netdev(dev);
657         return ERR_PTR(err);
658 }
659
660 /* Open/initialize the board.  This is called (in the current kernel)
661    sometime after booting when the 'ifconfig' program is run.
662
663    This routine should set everything up anew at each open, even
664    registers that "should" only need to be set once at boot, so that
665    there is non-reboot way to recover if something goes wrong.
666  */
667 static int
668 pamsnet_open(struct net_device *dev) {
669         struct net_local *lp = netdev_priv(dev);
670
671         if (pamsnet_debug > 0)
672                 printk("pamsnet_open\n");
673         stdma_lock(pamsnet_intr, NULL);
674         DISABLE_IRQ();
675
676         /* Reset the hardware here.
677          */
678         if (!if_up)
679                 start(lance_target);
680         if_up = 1;
681         lp->open_time = 0;      /*jiffies*/
682         lp->poll_time = MAX_POLL_TIME;
683
684         dev->tbusy = 0;
685         dev->interrupt = 0;
686         dev->start = 1;
687
688         ENABLE_IRQ();
689         stdma_release();
690         pamsnet_timer.data = (long)dev;
691         pamsnet_timer.expires = jiffies + lp->poll_time;
692         add_timer(&pamsnet_timer);
693         return 0;
694 }
695
696 static int
697 pamsnet_send_packet(struct sk_buff *skb, struct net_device *dev) {
698         struct net_local *lp = netdev_priv(dev);
699         unsigned long flags;
700
701         /* Block a timer-based transmit from overlapping.  This could better be
702          * done with atomic_swap(1, dev->tbusy), but set_bit() works as well.
703          */
704         local_irq_save(flags);
705
706         if (stdma_islocked()) {
707                 local_irq_restore(flags);
708                 lp->stats.tx_errors++;
709         }
710         else {
711                 int length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
712                 unsigned long buf = virt_to_phys(skb->data);
713                 int stat;
714
715                 stdma_lock(pamsnet_intr, NULL);
716                 DISABLE_IRQ();
717
718                 local_irq_restore(flags);
719                 if( !STRAM_ADDR(buf+length-1) ) {
720                         skb_copy_from_linear_data(skb, nic_packet->buffer,
721                                                   length);
722                         buf = (unsigned long)phys_nic_packet;
723                 }
724
725                 dma_cache_maintenance(buf, length, 1);
726
727                 stat = sendpkt(lance_target, (unsigned char *)buf, length);
728                 ENABLE_IRQ();
729                 stdma_release();
730
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);
737
738         return 0;
739 }
740
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;
750
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);
764
765         boguscount = testpkt(lance_target);
766         if( lp->poll_time < MAX_POLL_TIME ) lp->poll_time++;
767
768         while(boguscount--) {
769                 pkt_len = receivepkt(lance_target, phys_nic_packet);
770
771                 if( pkt_len < 60 ) break;
772
773                 /* Good packet... */
774
775                 dma_cache_maintenance((unsigned long)phys_nic_packet, pkt_len, 0);
776
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;
781
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;
793
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         }
803
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          */
808
809         ENABLE_IRQ();
810         stdma_release();
811         return;
812 }
813
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);
821
822         if( pamsnet_debug > 0 && (lp->open_time++ & 7) == 8 )
823                 printk("pamsnet_tick: %ld\n", lp->open_time);
824
825         pamsnet_poll_rx(dev);
826
827         pamsnet_timer.expires = jiffies + lp->poll_time;
828         add_timer(&pamsnet_timer);
829 }
830
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);
836
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();
842
843         if (if_up)
844                 stop(lance_target);
845         if_up = 0;
846
847         lp->open_time = 0;
848
849         dev->tbusy = 1;
850         dev->start = 0;
851
852         ENABLE_IRQ();
853         stdma_release();
854         return 0;
855 }
856
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 }
865
866
867 #ifdef MODULE
868
869 static struct net_device *pam_dev;
870
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 }
878
879 void cleanup_module(void)
880 {
881         unregister_netdev(pam_dev);
882         free_netdev(pam_dev);
883 }
884
885 #endif /* MODULE */
886
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  */