?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kmemtrace: SLOB hooks.
[linux-2.6/kmemtrace.git] / drivers / net / apne.c
blob867f6fff543c848bfd95a741173c746005344017
1 /*
2 * Amiga Linux/68k 8390 based PCMCIA Ethernet Driver for the Amiga 1200
3 *
4 * (C) Copyright 1997 Alain Malek
5 * (Alain.Malek@cryogen.com)
6 *
7 * ----------------------------------------------------------------------------
8 *
9 * This program is based on
10 *
11 * ne.c: A general non-shared-memory NS8390 ethernet driver for linux
12 * Written 1992-94 by Donald Becker.
13 *
14 * 8390.c: A general NS8390 ethernet driver core for linux.
15 * Written 1992-94 by Donald Becker.
16 *
17 * cnetdevice: A Sana-II ethernet driver for AmigaOS
18 * Written by Bruce Abbott (bhabbott@inhb.co.nz)
19 *
20 * ----------------------------------------------------------------------------
21 *
22 * This file is subject to the terms and conditions of the GNU General Public
23 * License. See the file COPYING in the main directory of the Linux
24 * distribution for more details.
25 *
26 * ----------------------------------------------------------------------------
27 *
28 */
29
30
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/errno.h>
34 #include <linux/pci.h>
35 #include <linux/init.h>
36 #include <linux/delay.h>
37 #include <linux/netdevice.h>
38 #include <linux/etherdevice.h>
39 #include <linux/jiffies.h>
40
41 #include <asm/system.h>
42 #include <asm/io.h>
43 #include <asm/setup.h>
44 #include <asm/amigaints.h>
45 #include <asm/amigahw.h>
46 #include <asm/amigayle.h>
47 #include <asm/amipcmcia.h>
48
49 #include "8390.h"
50
51 /* ---- No user-serviceable parts below ---- */
52
53 #define DRV_NAME "apne"
54
55 #define NE_BASE (dev->base_addr)
56 #define NE_CMD 0x00
57 #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
58 #define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
59 #define NE_IO_EXTENT 0x20
60
61 #define NE_EN0_ISR 0x07
62 #define NE_EN0_DCFG 0x0e
63
64 #define NE_EN0_RSARLO 0x08
65 #define NE_EN0_RSARHI 0x09
66 #define NE_EN0_RCNTLO 0x0a
67 #define NE_EN0_RXCR 0x0c
68 #define NE_EN0_TXCR 0x0d
69 #define NE_EN0_RCNTHI 0x0b
70 #define NE_EN0_IMR 0x0f
71
72 #define NE1SM_START_PG 0x20 /* First page of TX buffer */
73 #define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */
74 #define NESM_START_PG 0x40 /* First page of TX buffer */
75 #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
76
77
78 struct net_device * __init apne_probe(int unit);
79 static int apne_probe1(struct net_device *dev, int ioaddr);
80
81 static int apne_open(struct net_device *dev);
82 static int apne_close(struct net_device *dev);
83
84 static void apne_reset_8390(struct net_device *dev);
85 static void apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
86 int ring_page);
87 static void apne_block_input(struct net_device *dev, int count,
88 struct sk_buff *skb, int ring_offset);
89 static void apne_block_output(struct net_device *dev, const int count,
90 const unsigned char *buf, const int start_page);
91 static irqreturn_t apne_interrupt(int irq, void *dev_id);
92
93 static int init_pcmcia(void);
94
95 /* IO base address used for nic */
96
97 #define IOBASE 0x300
98
99 /*
100 use MANUAL_CONFIG and MANUAL_OFFSET for enabling IO by hand
101 you can find the values to use by looking at the cnet.device
102 config file example (the default values are for the CNET40BC card)
103 */
104
105 /*
106 #define MANUAL_CONFIG 0x20
107 #define MANUAL_OFFSET 0x3f8
108
109 #define MANUAL_HWADDR0 0x00
110 #define MANUAL_HWADDR1 0x12
111 #define MANUAL_HWADDR2 0x34
112 #define MANUAL_HWADDR3 0x56
113 #define MANUAL_HWADDR4 0x78
114 #define MANUAL_HWADDR5 0x9a
115 */
116
117 static const char version[] =
118 "apne.c:v1.1 7/10/98 Alain Malek (Alain.Malek@cryogen.ch)\n";
119
120 static int apne_owned; /* signal if card already owned */
121
122 struct net_device * __init apne_probe(int unit)
123 {
124 struct net_device *dev;
125 #ifndef MANUAL_CONFIG
126 char tuple[8];
127 #endif
128 int err;
129
130 if (!MACH_IS_AMIGA)
131 return ERR_PTR(-ENODEV);
132
133 if (apne_owned)
134 return ERR_PTR(-ENODEV);
135
136 if ( !(AMIGAHW_PRESENT(PCMCIA)) )
137 return ERR_PTR(-ENODEV);
138
139 printk("Looking for PCMCIA ethernet card : ");
140
141 /* check if a card is inserted */
142 if (!(PCMCIA_INSERTED)) {
143 printk("NO PCMCIA card inserted\n");
144 return ERR_PTR(-ENODEV);
145 }
146
147 dev = alloc_ei_netdev();
148 if (!dev)
149 return ERR_PTR(-ENOMEM);
150 if (unit >= 0) {
151 sprintf(dev->name, "eth%d", unit);
152 netdev_boot_setup_check(dev);
153 }
154
155 /* disable pcmcia irq for readtuple */
156 pcmcia_disable_irq();
157
158 #ifndef MANUAL_CONFIG
159 if ((pcmcia_copy_tuple(CISTPL_FUNCID, tuple, 8) < 3) ||
160 (tuple[2] != CISTPL_FUNCID_NETWORK)) {
161 printk("not an ethernet card\n");
162 /* XXX: shouldn't we re-enable irq here? */
163 free_netdev(dev);
164 return ERR_PTR(-ENODEV);
165 }
166 #endif
167
168 printk("ethernet PCMCIA card inserted\n");
169
170 if (!init_pcmcia()) {
171 /* XXX: shouldn't we re-enable irq here? */
172 free_netdev(dev);
173 return ERR_PTR(-ENODEV);
174 }
175
176 if (!request_region(IOBASE, 0x20, DRV_NAME)) {
177 free_netdev(dev);
178 return ERR_PTR(-EBUSY);
179 }
180
181 err = apne_probe1(dev, IOBASE);
182 if (err) {
183 release_region(IOBASE, 0x20);
184 free_netdev(dev);
185 return ERR_PTR(err);
186 }
187 err = register_netdev(dev);
188 if (!err)
189 return dev;
190
191 pcmcia_disable_irq();
192 free_irq(IRQ_AMIGA_PORTS, dev);
193 pcmcia_reset();
194 release_region(IOBASE, 0x20);
195 free_netdev(dev);
196 return ERR_PTR(err);
197 }
198
199 static int __init apne_probe1(struct net_device *dev, int ioaddr)
200 {
201 int i;
202 unsigned char SA_prom[32];
203 int wordlength = 2;
204 const char *name = NULL;
205 int start_page, stop_page;
206 #ifndef MANUAL_HWADDR0
207 int neX000, ctron;
208 #endif
209 static unsigned version_printed;
210 DECLARE_MAC_BUF(mac);
211
212 if (ei_debug && version_printed++ == 0)
213 printk(version);
214
215 printk("PCMCIA NE*000 ethercard probe");
216
217 /* Reset card. Who knows what dain-bramaged state it was left in. */
218 { unsigned long reset_start_time = jiffies;
219
220 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
221
222 while ((inb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0)
223 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
224 printk(" not found (no reset ack).\n");
225 return -ENODEV;
226 }
227
228 outb(0xff, ioaddr + NE_EN0_ISR); /* Ack all intr. */
229 }
230
231 #ifndef MANUAL_HWADDR0
232
233 /* Read the 16 bytes of station address PROM.
234 We must first initialize registers, similar to NS8390_init(eifdev, 0).
235 We can't reliably read the SAPROM address without this.
236 (I learned the hard way!). */
237 {
238 struct {unsigned long value, offset; } program_seq[] = {
239 {E8390_NODMA+E8390_PAGE0+E8390_STOP, NE_CMD}, /* Select page 0*/
240 {0x48, NE_EN0_DCFG}, /* Set byte-wide (0x48) access. */
241 {0x00, NE_EN0_RCNTLO}, /* Clear the count regs. */
242 {0x00, NE_EN0_RCNTHI},
243 {0x00, NE_EN0_IMR}, /* Mask completion irq. */
244 {0xFF, NE_EN0_ISR},
245 {E8390_RXOFF, NE_EN0_RXCR}, /* 0x20 Set to monitor */
246 {E8390_TXOFF, NE_EN0_TXCR}, /* 0x02 and loopback mode. */
247 {32, NE_EN0_RCNTLO},
248 {0x00, NE_EN0_RCNTHI},
249 {0x00, NE_EN0_RSARLO}, /* DMA starting at 0x0000. */
250 {0x00, NE_EN0_RSARHI},
251 {E8390_RREAD+E8390_START, NE_CMD},
252 };
253 for (i = 0; i < ARRAY_SIZE(program_seq); i++) {
254 outb(program_seq[i].value, ioaddr + program_seq[i].offset);
255 }
256
257 }
258 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
259 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
260 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
261 if (SA_prom[i] != SA_prom[i+1])
262 wordlength = 1;
263 }
264
265 /* At this point, wordlength *only* tells us if the SA_prom is doubled
266 up or not because some broken PCI cards don't respect the byte-wide
267 request in program_seq above, and hence don't have doubled up values.
268 These broken cards would otherwise be detected as an ne1000. */
269
270 if (wordlength == 2)
271 for (i = 0; i < 16; i++)
272 SA_prom[i] = SA_prom[i+i];
273
274 if (wordlength == 2) {
275 /* We must set the 8390 for word mode. */
276 outb(0x49, ioaddr + NE_EN0_DCFG);
277 start_page = NESM_START_PG;
278 stop_page = NESM_STOP_PG;
279 } else {
280 start_page = NE1SM_START_PG;
281 stop_page = NE1SM_STOP_PG;
282 }
283
284 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
285 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
286
287 /* Set up the rest of the parameters. */
288 if (neX000) {
289 name = (wordlength == 2) ? "NE2000" : "NE1000";
290 } else if (ctron) {
291 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
292 start_page = 0x01;
293 stop_page = (wordlength == 2) ? 0x40 : 0x20;
294 } else {
295 printk(" not found.\n");
296 return -ENXIO;
297
298 }
299
300 #else
301 wordlength = 2;
302 /* We must set the 8390 for word mode. */
303 outb(0x49, ioaddr + NE_EN0_DCFG);
304 start_page = NESM_START_PG;
305 stop_page = NESM_STOP_PG;
306
307 SA_prom[0] = MANUAL_HWADDR0;
308 SA_prom[1] = MANUAL_HWADDR1;
309 SA_prom[2] = MANUAL_HWADDR2;
310 SA_prom[3] = MANUAL_HWADDR3;
311 SA_prom[4] = MANUAL_HWADDR4;
312 SA_prom[5] = MANUAL_HWADDR5;
313 name = "NE2000";
314 #endif
315
316 dev->base_addr = ioaddr;
317 dev->irq = IRQ_AMIGA_PORTS;
318
319 /* Install the Interrupt handler */
320 i = request_irq(dev->irq, apne_interrupt, IRQF_SHARED, DRV_NAME, dev);
321 if (i) return i;
322
323 for(i = 0; i < ETHER_ADDR_LEN; i++)
324 dev->dev_addr[i] = SA_prom[i];
325
326 printk(" %s\n", print_mac(mac, dev->dev_addr));
327
328 printk("%s: %s found.\n", dev->name, name);
329
330 ei_status.name = name;
331 ei_status.tx_start_page = start_page;
332 ei_status.stop_page = stop_page;
333 ei_status.word16 = (wordlength == 2);
334
335 ei_status.rx_start_page = start_page + TX_PAGES;
336
337 ei_status.reset_8390 = &apne_reset_8390;
338 ei_status.block_input = &apne_block_input;
339 ei_status.block_output = &apne_block_output;
340 ei_status.get_8390_hdr = &apne_get_8390_hdr;
341 dev->open = &apne_open;
342 dev->stop = &apne_close;
343 #ifdef CONFIG_NET_POLL_CONTROLLER
344 dev->poll_controller = ei_poll;
345 #endif
346 NS8390_init(dev, 0);
347
348 pcmcia_ack_int(pcmcia_get_intreq()); /* ack PCMCIA int req */
349 pcmcia_enable_irq();
350
351 apne_owned = 1;
352
353 return 0;
354 }
355
356 static int
357 apne_open(struct net_device *dev)
358 {
359 ei_open(dev);
360 return 0;
361 }
362
363 static int
364 apne_close(struct net_device *dev)
365 {
366 if (ei_debug > 1)
367 printk("%s: Shutting down ethercard.\n", dev->name);
368 ei_close(dev);
369 return 0;
370 }
371
372 /* Hard reset the card. This used to pause for the same period that a
373 8390 reset command required, but that shouldn't be necessary. */
374 static void
375 apne_reset_8390(struct net_device *dev)
376 {
377 unsigned long reset_start_time = jiffies;
378
379 init_pcmcia();
380
381 if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);
382
383 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
384
385 ei_status.txing = 0;
386 ei_status.dmaing = 0;
387
388 /* This check _should_not_ be necessary, omit eventually. */
389 while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
390 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
391 printk("%s: ne_reset_8390() did not complete.\n", dev->name);
392 break;
393 }
394 outb(ENISR_RESET, NE_BASE + NE_EN0_ISR); /* Ack intr. */
395 }
396
397 /* Grab the 8390 specific header. Similar to the block_input routine, but
398 we don't need to be concerned with ring wrap as the header will be at
399 the start of a page, so we optimize accordingly. */
400
401 static void
402 apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
403 {
404
405 int nic_base = dev->base_addr;
406 int cnt;
407 char *ptrc;
408 short *ptrs;
409
410 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
411 if (ei_status.dmaing) {
412 printk("%s: DMAing conflict in ne_get_8390_hdr "
413 "[DMAstat:%d][irqlock:%d][intr:%d].\n",
414 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
415 return;
416 }
417
418 ei_status.dmaing |= 0x01;
419 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
420 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
421 outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
422 outb(0, nic_base + NE_EN0_RCNTHI);
423 outb(0, nic_base + NE_EN0_RSARLO); /* On page boundary */
424 outb(ring_page, nic_base + NE_EN0_RSARHI);
425 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
426
427 if (ei_status.word16) {
428 ptrs = (short*)hdr;
429 for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
430 *ptrs++ = inw(NE_BASE + NE_DATAPORT);
431 } else {
432 ptrc = (char*)hdr;
433 for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
434 *ptrc++ = inb(NE_BASE + NE_DATAPORT);
435 }
436
437 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
438 ei_status.dmaing &= ~0x01;
439
440 le16_to_cpus(&hdr->count);
441 }
442
443 /* Block input and output, similar to the Crynwr packet driver. If you
444 are porting to a new ethercard, look at the packet driver source for hints.
445 The NEx000 doesn't share the on-board packet memory -- you have to put
446 the packet out through the "remote DMA" dataport using outb. */
447
448 static void
449 apne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
450 {
451 int nic_base = dev->base_addr;
452 char *buf = skb->data;
453 char *ptrc;
454 short *ptrs;
455 int cnt;
456
457 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
458 if (ei_status.dmaing) {
459 printk("%s: DMAing conflict in ne_block_input "
460 "[DMAstat:%d][irqlock:%d][intr:%d].\n",
461 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
462 return;
463 }
464 ei_status.dmaing |= 0x01;
465 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
466 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
467 outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
468 outb(count >> 8, nic_base + NE_EN0_RCNTHI);
469 outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
470 outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
471 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
472 if (ei_status.word16) {
473 ptrs = (short*)buf;
474 for (cnt = 0; cnt < (count>>1); cnt++)
475 *ptrs++ = inw(NE_BASE + NE_DATAPORT);
476 if (count & 0x01) {
477 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
478 }
479 } else {
480 ptrc = (char*)buf;
481 for (cnt = 0; cnt < count; cnt++)
482 *ptrc++ = inb(NE_BASE + NE_DATAPORT);
483 }
484
485 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
486 ei_status.dmaing &= ~0x01;
487 }
488
489 static void
490 apne_block_output(struct net_device *dev, int count,
491 const unsigned char *buf, const int start_page)
492 {
493 int nic_base = NE_BASE;
494 unsigned long dma_start;
495 char *ptrc;
496 short *ptrs;
497 int cnt;
498
499 /* Round the count up for word writes. Do we need to do this?
500 What effect will an odd byte count have on the 8390?
501 I should check someday. */
502 if (ei_status.word16 && (count & 0x01))
503 count++;
504
505 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
506 if (ei_status.dmaing) {
507 printk("%s: DMAing conflict in ne_block_output."
508 "[DMAstat:%d][irqlock:%d][intr:%d]\n",
509 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
510 return;
511 }
512 ei_status.dmaing |= 0x01;
513 /* We should already be in page 0, but to be safe... */
514 outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
515
516 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
517
518 /* Now the normal output. */
519 outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
520 outb(count >> 8, nic_base + NE_EN0_RCNTHI);
521 outb(0x00, nic_base + NE_EN0_RSARLO);
522 outb(start_page, nic_base + NE_EN0_RSARHI);
523
524 outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
525 if (ei_status.word16) {
526 ptrs = (short*)buf;
527 for (cnt = 0; cnt < count>>1; cnt++)
528 outw(*ptrs++, NE_BASE+NE_DATAPORT);
529 } else {
530 ptrc = (char*)buf;
531 for (cnt = 0; cnt < count; cnt++)
532 outb(*ptrc++, NE_BASE + NE_DATAPORT);
533 }
534
535 dma_start = jiffies;
536
537 while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
538 if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */
539 printk("%s: timeout waiting for Tx RDC.\n", dev->name);
540 apne_reset_8390(dev);
541 NS8390_init(dev,1);
542 break;
543 }
544
545 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
546 ei_status.dmaing &= ~0x01;
547 return;
548 }
549
550 static irqreturn_t apne_interrupt(int irq, void *dev_id)
551 {
552 unsigned char pcmcia_intreq;
553
554 if (!(gayle.inten & GAYLE_IRQ_IRQ))
555 return IRQ_NONE;
556
557 pcmcia_intreq = pcmcia_get_intreq();
558
559 if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
560 pcmcia_ack_int(pcmcia_intreq);
561 return IRQ_NONE;
562 }
563 if (ei_debug > 3)
564 printk("pcmcia intreq = %x\n", pcmcia_intreq);
565 pcmcia_disable_irq(); /* to get rid of the sti() within ei_interrupt */
566 ei_interrupt(irq, dev_id);
567 pcmcia_ack_int(pcmcia_get_intreq());
568 pcmcia_enable_irq();
569 return IRQ_HANDLED;
570 }
571
572 #ifdef MODULE
573 static struct net_device *apne_dev;
574
575 static int __init apne_module_init(void)
576 {
577 apne_dev = apne_probe(-1);
578 if (IS_ERR(apne_dev))
579 return PTR_ERR(apne_dev);
580 return 0;
581 }
582
583 static void __exit apne_module_exit(void)
584 {
585 unregister_netdev(apne_dev);
586
587 pcmcia_disable_irq();
588
589 free_irq(IRQ_AMIGA_PORTS, apne_dev);
590
591 pcmcia_reset();
592
593 release_region(IOBASE, 0x20);
594
595 free_netdev(apne_dev);
596 }
597 module_init(apne_module_init);
598 module_exit(apne_module_exit);
599 #endif
600
601 static int init_pcmcia(void)
602 {
603 u_char config;
604 #ifndef MANUAL_CONFIG
605 u_char tuple[32];
606 int offset_len;
607 #endif
608 u_long offset;
609
610 pcmcia_reset();
611 pcmcia_program_voltage(PCMCIA_0V);
612 pcmcia_access_speed(PCMCIA_SPEED_250NS);
613 pcmcia_write_enable();
614
615 #ifdef MANUAL_CONFIG
616 config = MANUAL_CONFIG;
617 #else
618 /* get and write config byte to enable IO port */
619
620 if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
621 return 0;
622
623 config = tuple[2] & 0x3f;
624 #endif
625 #ifdef MANUAL_OFFSET
626 offset = MANUAL_OFFSET;
627 #else
628 if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
629 return 0;
630
631 offset_len = (tuple[2] & 0x3) + 1;
632 offset = 0;
633 while(offset_len--) {
634 offset = (offset << 8) | tuple[4+offset_len];
635 }
636 #endif
637
638 out_8(GAYLE_ATTRIBUTE+offset, config);
639
640 return 1;
641 }
642
643 MODULE_LICENSE("GPL");
kmemtrace - Kernel memory tracer