Makefile100664 1100 330 1005 6535546415 11033 0ustar amyljedit# Comment/uncomment the following line to enable/disable debugging DEBUG = y # Change it here or specify it on the "make" commandline INCLUDEDIR = /usr/include ifeq ($(DEBUG),y) DEBFLAGS = -O -g -DSAD_DEBUG else DEBFLAGS = -O2 endif CFLAGS = -D__KERNEL__ -DMODULE -Wall $(DEBFLAGS) CFLAGS += -I$(INCLUDEDIR) OBJS = sad.o all: $(OBJS) install: mkdir -p /lib/modules/$(VER)/misc /lib/modules/misc install -c $(OBJS) /lib/modules/$(VER)/misc install -c $(OBJS) /lib/modules/misc clean: rm -f *.o *~ core README100664 1100 330 30 6537053526 10206 0ustar amyljedit Sorry, not ready yet. piano.c100664 1100 330 13702 6536034767 10677 0ustar amyljedit#include #include #include #include #include #include #include #include #include #include #include #include #define VERSION "0.91" int tmp; /* for debugging */ #define OPTION "medium raw" extern int getfd(); int fd; int oldkbmode; struct termios old, new; struct hz { int key; double freq; } hz[] = { #define DO(k,h) {k,h*2*M_PI/8000.0}, DO(86,246.94) DO(44,261.62) DO(31,277.18) DO(45,293.66) DO(32,311.12) DO(46,329.62) DO(47,349.22) DO(34,369.99) DO(48,391.99) DO(35,415.30) DO(49,440.00) DO(36,466.16) DO(50,493.88) DO(51,523.25) DO(38,554.36) DO(52,587.32) DO(39,622.25) DO(53,659.25) DO(16,523.25) DO(3,554.36) DO(17,587.32) DO(4,622.25) DO(18,659.25) DO(19,698.45) DO(6,739.99) DO(20,783.99) DO(7,830.61) DO(21,880.00) DO(8,932.32) DO(22,987.76) DO(23,1046.50) DO(10,1108.73) DO(24,1174.66) DO(11,1244.50) DO(25,1318.51) DO(26,1396.91) DO(13,1479.98) DO(27,1567.98) {0,0} }; /* * version 0.81 of showkey would restore kbmode unconditially to XLATE, * thus making the console unusable when it was called under X. */ void get_mode(void) { char *m; if (ioctl(fd, KDGKBMODE, &oldkbmode)) { perror("KDGKBMODE"); exit(1); } switch(oldkbmode) { case K_RAW: m = "RAW"; break; case K_XLATE: m = "XLATE"; break; case K_MEDIUMRAW: m = "MEDIUMRAW"; break; default: m = "?UNKNOWN?"; break; } printf("kb mode was %s\n", m); if (oldkbmode != K_XLATE) { printf("[ if you are trying this under X, it might not work\n"); printf("since the X server is also reading /dev/console ]\n"); } printf("\n"); } void clean_up(void) { if (ioctl(fd, KDSKBMODE, oldkbmode)) { perror("KDSKBMODE"); exit(1); } tmp = tcsetattr(fd, 0, &old); if (tmp) printf("tcsetattr = %d\n", tmp); close(fd); } void die(int x) { printf("caught signal %d, cleaning up...\n", x); clean_up(); exit(1); } void watch_dog(int x) { clean_up(); exit(0); } int addkeytoset(unsigned char key, int islast) { static keyset[10]; static double fset[10]; static unsigned long count=0; static int fd=-1; static unsigned char buffer[80000]; fd_set fdset; int i, j, val, nnote, maxnote; struct hz *ptr; static int change=0; struct timeval notime={0,0}; if (fd<0) { fd=open("/dev/audio",O_WRONLY|O_NONBLOCK); count=0; } if (fd<0) { fprintf(stderr,"/dev/audio: %s\n",strerror(errno)); clean_up(); exit(1); } if(key&0x80) { /* old key, cleanup */ for (i=0; i<10; i++) { if (keyset[i]==(key&0x7f)) { keyset[i]=0; fset[i]=0.0; change++; break; } } } else { /* new (or repeated) key */ for (i=0; i<10; i++) if (keyset[i]==key) break; if(i==10) { for (i=0; i<10; i++) if (keyset[i]==0) break; if (key==10) return 0; for (ptr=hz; ptr->key; ptr++) { if (ptr->key==key) { keyset[i]=key; fset[i]=ptr->freq; change++; } } } } if (!islast) return 0; if (change) { close(fd); change=0; count=0; fd=open("/dev/audio",O_WRONLY|O_NONBLOCK); if (fd<0) { fprintf(stderr,"/dev/audio: %s\n",strerror(errno)); clean_up(); exit(1); } } nnote=0; maxnote=0; for (i=0; i<10; i++) if (fset[i]) { nnote++; maxnote=i+1; } for (j=count; (j to terminate\n"); while (1) { unsigned char key; n = read(fd, buf, sizeof(buf)); for (i = 0; i < n; i++) { key=buf[i]; /* printf("%02x\n",key); */ addkeytoset(key,i==n-1); if (key&0x80) { if ( (buf[i]&0x7f) == last) { ioctl(fd,KIOCSOUND,0); last = 0; } continue; } if (buf[i]==last) continue; if (buf[i]==1) { clean_up(); exit(0); } last = key; } } clean_up(); exit(0); } sad.c100664 1100 330 24361 6536034721 10331 0ustar amyljedit/* * sad.c, Copyright (c) Alessandro Rubini, 1998 */ #ifndef __KERNEL__ # define __KERNEL__ #endif #ifndef MODULE # define MODULE #endif #undef PDEBUG /* undef it, just in case */ #ifdef SAD_DEBUG # ifdef __KERNEL__ /* This one if debugging is on, and kernel space */ # define PDEBUG(fmt, args...) printk( KERN_DEBUG "sad: " fmt, ## args) # else /* This one for user space */ # define PDEBUG(fmt, args...) fprintf(stderr, fmt, ## args) # endif #else # define PDEBUG(fmt, args...) /* not debugging: nothing */ #endif #undef PDEBUGG #define PDEBUGG(fmt, args...) /* nothing: it's a placeholder */ #include #include #include /* printk() */ #include /* everything... */ #include /* error codes */ #include #include #include #include #include #include #include "sysdep-2.1.h" int sad_major = 0; int sad_base = 0x378; /* intel: default to lp0 */ int sad_irq = -1; /*=====================================================================*/ /* managing data buffers */ #define IBUFFER_ORDER 0 /* one page */ #define OBUFFER_ORDER 0 /* one page, too (but you'd need to increase it) */ #define IBUFFER_MASK ((1 << (PAGE_SHIFT+IBUFFER_ORDER)) -1) #define OBUFFER_MASK ((1 << (PAGE_SHIFT+OBUFFER_ORDER)) -1) #define IBUFFER_SIZE (PAGE_SIZE << IBUFFER_ORDER) #define OBUFFER_SIZE (PAGE_SIZE << OBUFFER_ORDER) static unsigned long ibuffer = 0, obuffer = 0; /* reading data: irq writes at head */ static unsigned long volatile ihead, itail; #define IBUFFER_EMPTY (ihead==itail) #define IBUFFER_FULL (((itail-ihead)&IBUFFER_MASK)==1) /* writing data: irq reads from tail */ static unsigned long volatile ohead, otail; #define OBUFFER_EMPTY (ohead==otail) #define OBUFFER_FREE ((otail-ohead-1)&OBUFFER_MASK) #define OBUFFER_FULL (!OBUFFER_FREE) /* #define OBUFFER_FULL (((otail-ohead)&OBUFFER_MASK)==1) */ #define OBUFFER_THRESHOLD 1024 /* don't awake unless at least 1k is free */ static struct wait_queue *inq, *outq, *closeq; #define SAD_IRQON() (outb(0x10,sad_base+2)) #define SAD_IRQOFF() (outb(0x00,sad_base+2)) /*=====================================================================*/ /* The actual hw mechanism */ static inline u8 convert(u8 byte) { u8 b = byte & 0x80 ? byte&0x7f : 0xff^byte; return ((b>>2)&0x3f) | b<<6; } #define OUTBYTE(b) outb(convert(b),sad_base) /*=====================================================================*/ /* open and close */ int sad_open (struct inode *inode, struct file *filp) { SAD_IRQON(); MOD_INC_USE_COUNT; return 0; } release_t sad_release (struct inode *inode, struct file *filp) { unsigned long flags; /* * If minor is 0, flush data to speaker before closing. * Otherwise, forget pending data. */ if (MINOR(inode->i_rdev)==0) interruptible_sleep_on(&closeq); else { save_flags(flags); cli(); ohead=otail; restore_flags(flags); } MOD_DEC_USE_COUNT; if (!MOD_IN_USE) SAD_IRQOFF(); release_return(0); } #ifdef __USE_OLD_SELECT__ int sad_poll (struct inode *inode, struct file *filp, int mode, select_table *table) { if (mode==SEL_IN) { if (!IBUFFER_EMPTY) return 1; /* readable */ select_wait (&inq, table); return 0; } if (mode==SEL_OUT) { if (!OBUFFER_FULL) return 1; /* writable */ select_wait (&outq, table); return 0; } return 0; /* not-exceptionable */ } #else unsigned int sad_poll (struct file *filp, poll_table *table) { int ret=0; poll_wait(&inq, table); poll_wait(&outq, table); if (!IBUFFER_EMPTY) ret |= POLLIN | POLLRDNORM; if (!OBUFFER_FULL) ret |= POLLOUT | POLLWRNORM; return ret; } #endif /*=====================================================================*/ /* read: returns interrupt timestamps */ read_write_t sad_read (struct inode *inode, struct file *filp, char *buf, count_t count) { int count0; while (IBUFFER_EMPTY) { if (filp->f_flags & O_NONBLOCK) return -EAGAIN; interruptible_sleep_on(&inq); if (current->signal & ~current->blocked) /* a signal arrived */ return -ERESTARTSYS; /* tell the fs layer to handle it */ /* else, loop */ } /* count0 is the number of readable data bytes */ count0 = ihead - itail; if (count0 < 0) /* wrapped */ count0 = ibuffer + IBUFFER_SIZE - itail; if (count0 < count) count = count0; copy_to_user(buf, (char *)itail, count); itail += count; if (itail == ibuffer + IBUFFER_SIZE) itail = ibuffer; return count; } /*=====================================================================*/ /* write: send out one byte each time we get an interrupt */ read_write_t sad_write (struct inode *inode, struct file *filp, const char *buf, count_t count) { int count0; PDEBUGG("write %4li (R %04lx,%04lx) (W %04lx,%04lx)\n",count, ihead&IBUFFER_MASK,itail&IBUFFER_MASK, ohead&OBUFFER_MASK,otail&OBUFFER_MASK); while (OBUFFER_FREE < OBUFFER_THRESHOLD) { if (filp->f_flags & O_NONBLOCK) return -EAGAIN; interruptible_sleep_on(&outq); if (current->signal & ~current->blocked) /* a signal arrived */ return -ERESTARTSYS; /* tell the fs layer to handle it */ /* else, loop */ } /* * Written data is placed at ohead, and output proceeds from otail * onwards. Free apace is therefore tail-head-1, or end-head; */ if (count > OBUFFER_FREE) count = OBUFFER_FREE; /* count0 is the number of writable data bytes */ count0 = otail - ohead -1; if (count0 < 0) /* wrapped */ count0 = obuffer + OBUFFER_SIZE - ohead; if (count0 < count) count = count0; copy_from_user((char *)ohead, buf, count); ohead += count; if (ohead == obuffer + OBUFFER_SIZE) ohead = obuffer; PDEBUGG("written %li\n",count); return count; } /*=====================================================================*/ lseek_t my_lseek(struct inode *, struct file *, lseek_off_t, int) { return -ESPIPE; } /*=====================================================================*/ struct file_operations sad_fops = { sad_lseek, sad_read, sad_write, NULL, /* sad_readdir */ sad_poll, NULL, /* sad_ioctl */ NULL, /* sad_mmap */ sad_open, sad_release, NULL, /* sad_fsync */ NULL, /* sad_fasync */ /* nothing more, fill with NULLs */ }; /*=====================================================================*/ void sad_interrupt(int irq, void *dev_id, struct pt_regs *regs) { static struct timeval tv, tv_last; unsigned long diff=0; if (!OBUFFER_EMPTY) { /* send out one byte */ OUTBYTE(*((u8 *)otail++)); if (otail == obuffer + OBUFFER_SIZE) /* wrap */ otail = obuffer; if (OBUFFER_FREE > OBUFFER_THRESHOLD) wake_up_interruptible(&outq); return; } wake_up_interruptible(&closeq); /* else, pass interrupts times to the reader */ do_gettimeofday(&tv); diff = (tv.tv_sec - tv_last.tv_sec) * 1000000 + (tv.tv_usec - tv_last.tv_usec); tv_last = tv; /* Write a 16 byte record. Assume IBUFFER_SIZE is a multiple of 16 */ ihead += sprintf((char *)ihead,"%15u\n", (int)diff); if (ihead == ibuffer + IBUFFER_SIZE) ihead = ibuffer; /* wrap */ wake_up_interruptible(&inq); /* awake any reading process */ } /*=====================================================================*/ #if 0 void sad_kernelprobe(void) { int count = 0; do { unsigned long mask; mask = probe_irq_on(); outb_p(0x10,sad_base+2); /* enable reporting */ outb_p(0x00,sad_base); /* clear the bit */ outb_p(0xFF,sad_base); /* set the bit: interrupt! */ outb_p(0x00,sad_base+2); /* disable reporting */ sad_irq = probe_irq_off(mask); if (sad_irq == 0) { /* none of them? */ printk(KERN_INFO "sad: no irq reported by probe\n"); sad_irq = -1; } /* * if more than one line has been activated, the result is * negative. We should service the interrupt (no need for lpt port) * and loop over again. Loop at most five times, then give up */ } while (sad_irq < 0 && count++ < 5); if (sad_irq < 0) printk("sad: probe failed %itimes, giving up\n", count); } #endif /*=====================================================================*/ void cleanup_module(void) { if (sad_irq >= 0) free_irq(sad_irq, NULL); if (sad_major > 0) unregister_chrdev(sad_major, "sad"); if (ibuffer) { free_pages(ibuffer,IBUFFER_ORDER); ibuffer=0; } if (obuffer) { free_pages(obuffer,OBUFFER_ORDER); obuffer=0; } release_region(sad_base,4); } /*=====================================================================*/ int init_module(void) { int result = check_region(sad_base,4); if (result) { printk(KERN_INFO "sad: can't get I/O address 0x%x\n",sad_base); return result; } request_region(sad_base,4,"sad"); ibuffer = __get_free_pages(GFP_KERNEL,IBUFFER_ORDER,0); ihead = itail = ibuffer; obuffer = __get_free_pages(GFP_KERNEL,OBUFFER_ORDER,0); ohead = otail = obuffer; if (!ibuffer || !obuffer) { /* allocation failed */ cleanup_module(); /* use your own function */ return -ENOMEM; } result = register_chrdev(sad_major, "sad", &sad_fops); if (result < 0) { cleanup_module(); /* use your own function */ return result; } if (sad_major == 0) sad_major = result; /* dynamic */ if (sad_irq < 0) /* not yet specified: force the default on */ switch(sad_base) { case 0x378: sad_irq = 7; break; case 0x278: sad_irq = 2; break; case 0x3bc: sad_irq = 5; break; } /* sad_kernelprobe(); */ result = request_irq(sad_irq, sad_interrupt, SA_INTERRUPT, "sad", NULL); if (result) { sad_irq=-1; cleanup_module(); /* use your own function */ return result; } return 0; } sad_load100664 1100 330 607 6535546246 11055 0ustar amyljedit#!/bin/sh module="sad" device="sad" group="wheel" mode="664" # invoke insmod with all arguments we got /sbin/insmod -f $module $* || exit 1 major=`cat /proc/devices | awk "\\$2==\"$module\" {print \\$1}"` rm -f /dev/${device} mknod /dev/${device} c $major 0 mknod /dev/${device}nb c $major 1 chgrp $group /dev/${device} /dev/${device}nb chmod $mode /dev/${device} /dev/${device}nb sad_unload100664 1100 330 261 6535546276 11417 0ustar amyljedit#!/bin/sh module="sad" device="sad" # invoke rmmod with all arguments we got /sbin/rmmod $module $* || exit 1 # Remove stale nodes rm -f /dev/${device} /dev/${device}nb sinu.c100664 1100 330 1135 6536034750 10514 0ustar amyljedit#include #include int main(int argc, char **argv) { int hz, minb, maxb, out; double amp; double count=0; if (argc!=4) { fprintf(stderr,"Use: sinu \n"); exit(1); } hz=atoi(argv[1]); minb=atoi(argv[2]); maxb=atoi(argv[3]); amp=(double)(maxb-minb)/2.0; fprintf(stderr,"%i hz, %i to %i (amp %lf)\n",hz,minb,maxb,amp); while (1) { /* u8 b = byte & 0x80 ? byte&0x7f : 0xff^byte; */ out=minb+amp+floor(amp*sin(count/8000.0*hz*2*M_PI)); putchar(out<128? out+128 : out^0xff); count++; } } square.c100664 1100 330 1345 6536034757 11050 0ustar amyljedit#include #include #include int main(int argc, char **argv) { int hz, minb, maxb; double amp; unsigned long count=0; FILE *res; if (argc!=3) { fprintf(stderr,"Use: quadra \n"); exit(1); } hz=10; minb=atoi(argv[1]); maxb=atoi(argv[2]); fprintf(stderr,"%lf hz, %i and %i\n",4000.0/hz,minb,maxb); res = freopen("/dev/audio","w",stdout); if (!res) { fprintf(stderr,"/dev/audio: %s\n",strerror(errno)); exit(1); } while (count <8000) { /* fprintf(stderr,"arg=%lf\n",count/8000.0*hz*2*M_PI); */ putchar((count/hz)&1 ? minb : maxb); count++; } fclose(stdout); return 0; } sysdep-2.1.h100664 1100 330 14612 6535546036 11400 0ustar amyljedit/* * sysdep-2.1.h -- a trial to centralize changes between 2.0 and 2.1.43 * * export rules changed in 2.1.18 * poll.h is there * cpu_to_le15 etc. appeared in 2.1.10 * they "p" and "s" forms appeared in 2.1.43 */ #ifndef _SYSDEP_21_H_ #define _SYSDEP_21_H_ #ifndef LINUX_VERSION_CODE # include #endif #ifndef VERSION_CODE # define VERSION_CODE(vers,rel,seq) ( ((vers)<<16) | ((rel)<<8) | (seq) ) #endif /* only allow 2.0.x and 2.1.y */ #if LINUX_VERSION_CODE < VERSION_CODE(2,0,0) # error "This kernel is too old: not supported by this file" #endif #if LINUX_VERSION_CODE < VERSION_CODE(2,1,0) # define LINUX_20 #else # define LINUX_21 #endif #include /* used later in this header */ /* Modularization issues */ /*......... begin-tag export */ #if LINUX_VERSION_CODE < VERSION_CODE(2,1,18) # define __USE_OLD_SYMTAB__ # define EXPORT_NO_SYMBOLS register_symtab(NULL); # define REGISTER_SYMTAB(tab) register_symtab(tab) #else # define REGISTER_SYMTAB(tab) /* nothing */ #endif /*......... end-tag export */ #ifdef __USE_OLD_SYMTAB__ # define __MODULE_STRING(s) /* nothing */ # define MODULE_PARM(v,t) /* nothing */ # define MODULE_PARM_DESC(v,t) /* nothing */ # define MODULE_AUTHOR(n) /* nothing */ # define MODULE_DESCRIPTION(d) /* nothing */ # define MODULE_SUPPORTED_DEVICE(n) /* nothing */ #endif /* * "select" changed in 2.1.23. The implementation is twin, but this * header is new */ #if LINUX_VERSION_CODE > VERSION_CODE(2,1,22) # include #else # define __USE_OLD_SELECT__ #endif /* Other change in the fops are solved using pseudo-types */ #ifdef LINUX_21 # define lseek_t long long # define lseek_off_t long long #else # define lseek_t int # define lseek_off_t off_t #endif /* changed the prototype of read/write */ #if defined(LINUX_21) || defined(__alpha__) # define count_t unsigned long # define read_write_t long #else # define count_t int # define read_write_t int #endif #if LINUX_VERSION_CODE < VERSION_CODE(2,1,31) # define release_t void # define release_return(x) return #else # define release_t int # define release_return(x) return (x) #endif /* * access to user space: use the 2.1 functions, * and implement them as macros for 2.0 */ #ifdef LINUX_20 # include # define access_ok(t,a,sz) (verify_area((t),(a),(sz)) ? 0 : 1) # define verify_area_20 verify_area # define copy_to_user(t,f,n) (memcpy_tofs(t,f,n), 0) # define __copy_to_user(t,f,n) copy_to_user((t),(f),(n)) # define copy_to_user_ret(t,f,n,r) copy_to_user((t),(f),(n)) # define copy_from_user(t,f,n) (memcpy_fromfs((t),(f),(n)), 0) # define __copy_from_user(t,f,n) copy_from_user((t),(f),(n)) # define copy_from_user_ret(t,f,n,r) copy_from_user((t),(f),(n)) # define PUT_USER(val,add) (put_user((val),(add)), 0) # define __PUT_USER(val,add) PUT_USER((val),(add)) # define PUT_USER_RET(val,add,ret) PUT_USER((val),(add)) # define GET_USER(dest,add) ((dest)=get_user((add)), 0) # define __GET_USER(dest,add) GET_USER((dest),(add)) # define GET_USER_RET(dest,add,ret) GET_USER((dest),(add)) #else # include # include # define verify_area_20(t,a,sz) (0) /* == success */ # define PUT_USER put_user # define __PUT_USER __put_user # define PUT_USER_RET put_user_ret # define GET_USER get_user # define __GET_USER __get_user # define GET_USER_RET get_user_ret #endif /* ioremap */ #ifdef LINUX_20 # define ioremap vremap # define iounmap vfree #endif /* The use_count of exec_domain and binfmt changed in 2.1.23 */ #ifdef LINUX_20 # define INCRCOUNT(p) ((p)->module ? __MOD_INC_USE_COUNT((p)->module) : 0) # define CURRCOUNT(p) ((p)->module && (p)->module->usecount) # define DECRCOUNT(p) ((p)->module ? __MOD_DEC_USE_COUNT((p)->module) : 0) #else # define INCRCOUNT(p) ((p)->use_count++) # define CURRCOUNT(p) ((p)->use_count) # define DECRCOUNT(p) ((p)->use_count--) #endif /* register_dynamic no more existent -- just have 0 as inum */ #if LINUX_VERSION_CODE >= VERSION_CODE(2,1,29) # define proc_register_dynamic proc_register #endif #if LINUX_VERSION_CODE < VERSION_CODE(2,1,37) # define test_and_set_bit(nr,addr) test_bit((nr),(addr)) # define test_and_clear_bit(nr,addr) clear_bit((nr),(addr)) # define test_and_change_bit(nr,addr) change_bit((nr),(addr)) #endif /* 2.1.30 removed these functions. Let's define them, just in case */ #if LINUX_VERSION_CODE > VERSION_CODE(2,1,29) # define queue_task_irq queue_task # define queue_task_irq_off queue_task #endif /* 2.1.10 and 2.1.43 introduced new functions. They are worth using */ #if LINUX_VERSION_CODE < VERSION_CODE(2,1,10) # include # ifdef __LITTLE_ENDIAN # define cpu_to_le16(x) (x) # define cpu_to_le32(x) (x) # define cpu_to_be16(x) htons((x)) # define cpu_to_be32(x) htonl((x)) # else # define cpu_to_be16(x) (x) # define cpu_to_be32(x) (x) extern inline __u16 cpu_to_le16(__u16 x) { return (x<<8) | (x>>8);} extern inline __u32 cpu_to_le32(__u32 x) { return((x>>24) | ((x>>8)&0xff00) | ((x<<8)&0xff0000) | (x<<24));} # endif # define le16_to_cpu(x) cpu_to_le16(x) # define le32_to_cpu(x) cpu_to_le32(x) # define be16_to_cpu(x) cpu_to_be16(x) # define be32_to_cpu(x) cpu_to_be32(x) #endif #if LINUX_VERSION_CODE < VERSION_CODE(2,1,43) # define cpu_to_le16p(addr) (cpu_to_le16(*(addr))) # define cpu_to_le32p(addr) (cpu_to_le32(*(addr))) # define cpu_to_be16p(addr) (cpu_to_be16(*(addr))) # define cpu_to_be32p(addr) (cpu_to_be32(*(addr))) extern inline void cpu_to_le16s(__u16 *a) {*a = cpu_to_le16(*a);} extern inline void cpu_to_le32s(__u16 *a) {*a = cpu_to_le32(*a);} extern inline void cpu_to_be16s(__u16 *a) {*a = cpu_to_be16(*a);} extern inline void cpu_to_be32s(__u16 *a) {*a = cpu_to_be32(*a);} # define le16_to_cpup(x) cpu_to_le16p(x) # define le32_to_cpup(x) cpu_to_le32p(x) # define be16_to_cpup(x) cpu_to_be16p(x) # define be32_to_cpup(x) cpu_to_be32p(x) # define le16_to_cpus(x) cpu_to_le16s(x) # define le32_to_cpus(x) cpu_to_le32s(x) # define be16_to_cpus(x) cpu_to_be16s(x) # define be32_to_cpus(x) cpu_to_be32s(x) #endif #if LINUX_VERSION_CODE < VERSION_CODE(2,1,15) # define __USE_OLD_REBUILD_HEADER__ #endif #if LINUX_VERSION_CODE < VERSION_CODE(2,1,30) # define in_interrupt() (intr_count!=0) #endif #endif /* _SYSDEP_21_H_ */