6827l1.txt0100664000204600003300000000071207700344005011443 0ustar jillljedit#!/bin/sh # # Mount the disks # mount -n -o remount,rw / mount -a # Start the logs. This could be removed from a # self contained unit. syslogd -m 0 klogd # This doesn't get started by default, but eases # debugging - could be left out ifconfig lo 127.0.0.1 # don't get bitten by the dog watchdog /dev/watchdog 10 # we want access. /usr/sbin/utelnetd -d # install the new modules insmod pump insmod led # start the daemons pumpmon -d pumpserv -d 6827l2.txt0100664000204600003300000001572707700344005011460 0ustar jillljedit/* * pump.c * * Sample the gpio pin periodically and report the * status as 'on' or 'off' to reflect the state of * the connected pump. This was based very * heavily on the examples in The Linux Kernel * Module Programming Guide. */ #include /* Kernel work */ #include /* A module */ #include #include #include #include #include /* For jiffies */ MODULE_LICENSE( "GPL" ); static __u16 *mmcrbase,*pio_fun,*pio_dir,*pio_dat; #define BUFSIZE 32 /* buffer to copy to user-land */ #define DMASK 0x1000; /* the gpio pin of interest */ /* * Module parameters to tweak the samples * * nsamp controls the number of microsamples to * take per macro sample. Each of the nsamp * samples is taken 1 jiffy apart. * * mper is the macro interval. One set of * microsamples is taken every mper seconds. * * verbose controls the logging of info to klog */ static int nsamp = HZ/60; /* want to sample as fast as possible for 1 period */ static int mper = 5; /* seconds per filtered datapoint */ static int verbose = 0; #define MAXSAMPLES HZ/2 MODULE_PARM( mper, "i" ); MODULE_PARM( nsamp, "i" ); MODULE_PARM( verbose, "i" ); /* * This timer is used to take N samples every M * seconds. * * The sample results are stored in a buffer and * checked for each read of the /proc/pump file. */ static struct timer_list timer; static unsigned char sample_buf[MAXSAMPLES]; static int pump_state = 0; static void sample( unsigned long data ){ static int remaining_samples = 0; __u16 dat; int ntimeout = 1; int mtimeout = HZ*mper - nsamp*ntimeout; if ( remaining_samples ){ /* * Take another microsample */ timer.expires = jiffies + ntimeout; remaining_samples--; dat = readw( pio_dat ) & DMASK; if ( dat == 0 ){ /* low true logic at the pin */ sample_buf[remaining_samples] = 1; } add_timer( &timer ); } else { /* * We have accumulated a full buffers worth of * samples. Decide if the pump is on. */ int i; char buf[MAXSAMPLES]; pump_state = 0; for( i = 0; i < nsamp; i++ ){ /* itegrate the pin signal */ pump_state += sample_buf[i]; /* convert to a printable buffer for osciloscope mode */ buf[i] = sample_buf[i] + '0'; /* clear the buffer for next time */ sample_buf[i] = 0; } buf[i] = '\0'; if((verbose==1 && pump_state) || (verbose>1) ){ /* print the signal trace */ printk( KERN_INFO "Sample buffer at tick (%ld) %s\n", jiffies, buf ); } /* long tick between samples */ remaining_samples = nsamp; timer.expires = jiffies + mtimeout; add_timer(&timer); } } static ssize_t pump_output( struct file *file, /* The file read */ char *buf, /* The buffer to put * data to (in the * user segment) */ size_t len, /* The length of the buffer */ loff_t *offset) /* Offset in the file - ignore */ { char my_buffer[BUFSIZE]; static int finished = 0; int i; if ( finished ){ /* flag so we indicate EOF */ finished = 0; return 0; } if ( pump_state ){ len = sprintf( my_buffer, "on\n" ); } else { len = sprintf( my_buffer, "off\n" ); } /* copy out to userlane */ for(i=0; i < len && my_buffer[i]; i++ ){ put_user( my_buffer[i], buf + i ); } finished = 1; return i; } static struct proc_dir_entry *pde; static int pump_permission( struct inode *inode, int op) { if (op==4 || (op==2 && current->euid==pde->uid)) return 0; /* If it's anything else, access is denied */ return -EACCES; } static int pump_open( struct inode *inode, struct file *file) { MOD_INC_USE_COUNT; return 0; } static int pump_close( struct inode *inode, struct file *file) { MOD_DEC_USE_COUNT; return 0; /* success */ } static struct file_operations file_ops = { NULL, /* module owner */ NULL, /* llseek */ pump_output, /* "read" from the file */ NULL, /* "write" to the file */ NULL, /* readdir */ NULL, /* poll */ NULL, /* ioctl */ NULL, /* mmap */ pump_open, /* Somebody opened the file */ NULL, /* flush */ pump_close, /* release */ NULL, /* fsync */ NULL, /* fasync */ NULL, /* lock */ NULL, /* readv */ NULL, /* writev */ NULL, /* sendpage */ NULL /* get_unmapped_area */ }; static struct inode_operations inode_ops = { NULL, /* create */ NULL, /* lookup */ NULL, /* link */ NULL, /* unlink */ NULL, /* symlink */ NULL, /* mkdir */ NULL, /* rmdir */ NULL, /* mknod */ NULL, /* rename */ NULL, /* readlink */ NULL, /* follow_link */ NULL, /* truncate */ pump_permission, /* check for permissions */ NULL, /* revalidate */ NULL, /* setattr */ NULL /* getattr */ }; static void start_timer( void ){ int ntimeout = 1; if ( verbose ){ printk( KERN_INFO " Starting timer (%dHZ) mper=%d, " "nsamp=%d\n", HZ, mper, nsamp ); } init_timer( &timer ); timer.expires = jiffies + ntimeout; timer.function = sample; timer.data = 0; add_timer( &timer ); } static int init() { if ( (pde = create_proc_entry( "pump", S_IFREG|S_IRUGO, &proc_root)) ){ unsigned long cbar = inl_p(0xfffc); __u16 fun, dir, dat; int n=0; /* set the various pde file structures */ pde->size = BUFSIZE; pde->proc_iops = &inode_ops; pde->proc_fops = &file_ops; /* taken from the wdt520.c watchdog code */ if ( cbar & 0x80000000 ){ mmcrbase = (__u16 *)(cbar & 0x3FFFFFFF); } else { mmcrbase = (__u16 *)0xFFFEF000; } pio_fun = (__u16 *)((char *)mmcrbase + 0xc20 ); pio_fun = ioremap( (unsigned long)pio_fun ,2 ); pio_dir = (__u16 *)((char *)mmcrbase + 0xc2a ); pio_dir = ioremap( (unsigned long)pio_dir ,2 ); pio_dat = (__u16 *)((char *)mmcrbase + 0xc30 ); pio_dat = ioremap( (unsigned long)pio_dat ,2 ); /* * Make sure PIO12 is set as an input */ dir = readw( pio_dir ); fun = readw( pio_fun ); dat = readw( pio_dat ); dir &= ~DMASK; fun &= ~DMASK; writew( fun, pio_fun ); writew( dir, pio_dir ); /* * ensure that the passed parameters are still * sensible */ if ( (nsamp == 0) || (nsamp >= MAXSAMPLES) ){ nsamp = MAXSAMPLES>>1; } while ( n < nsamp ){ sample_buf[n++] = 0; } start_timer(); return 0; } return -ENOMEM; } /* Cleanup - unregister our file from /proc */ static void cleanup() { iounmap( pio_fun ); iounmap( pio_dat ); iounmap( pio_dir ); del_timer( &timer ); remove_proc_entry(pde->name, &proc_root ); } module_init(init); module_exit(cleanup); 6827l3.txt0100664000204600003300000001136207700344005011450 0ustar jillljedit/* * This code is based very heavily (read pretty * much copied verbatim) from the Linux Kernel * Module Programming Guide. * * Parts of the Elan specific bits were gleaned * from the sc520 watcdog driver */ #include #include #include #include #include MODULE_LICENSE( "GPL" ); static __u16 *mmcrbase,*pio_fun,*pio_dir,*pio_dat; #define BUFSIZE 32 static ssize_t led_output( struct file *file, /* The file read */ char *buf, /* The buffer to put * data to (in the * user segment) */ size_t len, /* The length of the buffer */ loff_t *offset) /* Offset in the file - ignore */ { __u16 dat = readw( pio_dat ); char my_buffer[BUFSIZE]; static int finished = 0; int i; if ( finished ){ finished = 0; return 0; } if ( dat & 0x200 ){ len = sprintf( my_buffer, "on\n" ); } else { len = sprintf( my_buffer, "off\n" ); } for(i=0; i < len && my_buffer[i]; i++ ){ put_user( my_buffer[i], buf + i ); } finished = 1; return i; } static ssize_t led_input( struct file *file, /* The file itself */ const char *buf, /* The buffer with input */ size_t length, /* The buffer's length */ loff_t *offset) /* offset to file - ignore */ { int i; char my_buffer[BUFSIZE]; __u16 dat = readw( pio_dat ); for(i=0; ieui==pde->uid)) return 0; /* If it's anything else, access is denied */ return -EACCES; } static int led_open( struct inode *inode, struct file *file) { MOD_INC_USE_COUNT; return 0; } static int led_close( struct inode *inode, struct file *file) { MOD_DEC_USE_COUNT; return 0; /* success */ } static struct file_operations file_ops = { NULL, /* module owner */ NULL, /* llseek */ led_output, /* "read" from the file */ led_input, /* "write" to the file */ NULL, /* readdir */ NULL, /* poll */ NULL, /* ioctl */ NULL, /* mmap */ led_open, /* Somebody opened the file */ NULL, /* flush */ led_close, /* release */ NULL, /* fsync */ NULL, /* fasync */ NULL, /* lock */ NULL, /* readv */ NULL, /* writev */ NULL, /* sendpage */ NULL /* get_unmapped_area */ }; static struct inode_operations inode_ops = { NULL, /* create */ NULL, /* lookup */ NULL, /* link */ NULL, /* unlink */ NULL, /* symlink */ NULL, /* mkdir */ NULL, /* rmdir */ NULL, /* mknod */ NULL, /* rename */ NULL, /* readlink */ NULL, /* follow_link */ NULL, /* truncate */ led_permission, /* check for permissions */ NULL, /* revalidate */ NULL, /* setattr */ NULL /* getattr */ }; static int init() { if ( (pde = create_proc_entry( "led", S_IFREG|S_IRUGO|S_IWUSR, &proc_root)) ){ unsigned long cbar = inl_p(0xfffc); __u16 fun, dir, dat; pde->size = BUFSIZE; pde->proc_iops = &inode_ops; pde->proc_fops = &file_ops; if ( cbar & 0x80000000 ){ mmcrbase = (__u16 *)(cbar & 0x3FFFFFFF); } else { mmcrbase = (__u16 *)0xFFFEF000; } pio_fun = (__u16 *)((char *)mmcrbase + 0xc20 ); pio_fun = ioremap( (unsigned long)pio_fun ,2 ); pio_dir = (__u16 *)((char *)mmcrbase + 0xc2a ); pio_dir = ioremap( (unsigned long)pio_dir ,2 ); pio_dat = (__u16 *)((char *)mmcrbase + 0xc30 ); pio_dat = ioremap( (unsigned long)pio_dat ,2 ); /* * Make sure PIO12 is set as an output * (initially off) */ dir = readw( pio_dir ); fun = readw( pio_fun ); dat = readw( pio_dat ); dir |= 0x200; fun &= ~0x200; dat &= ~0x200; writew( fun, pio_fun ); writew( dir, pio_dir ); writew( dat, pio_dat ); return 0; } return -ENOMEM; } /* Cleanup - unregister our file from /proc */ static void cleanup() { iounmap( pio_fun ); iounmap( pio_dat ); iounmap( pio_dir ); remove_proc_entry(pde->name, &proc_root ); } module_init(init); module_exit(cleanup); 6827l4.txt0100664000204600003300000000324507700344005011452 0ustar jillljedit/************************************************* * pumpserv.c * * This daemon simply sits around listening to * port 5678 * * When someone (anyone) connects, we simply * respond with 'on' or 'off'. ************************************************/ #include #include #include #include #include #include #include #include #include #include int main( int argc, char *argv[] ){ int sockfd, newsockfd; struct sockaddr_in cli_addr, srv_addr; /* are we a daemon? */ if ( (argc>1) && (strcmp(argv[1], "-d" ) ==0 ) ){ if ( fork() ){ exit(0); } } /* socket, bind, listen */ sockfd=socket(AF_INET,SOCK_STREAM,0); bzero( (char *)&srv_addr, sizeof( srv_addr ) ); srv_addr.sin_family = AF_INET; srv_addr.sin_addr.s_addr = htonl(INADDR_ANY); srv_addr.sin_port = htons(5678); bind(sockfd, (struct sockaddr *)&srv_addr, sizeof(srv_addr) ); } listen( sockfd, 5 ); /* accept loop */ while( 1 ){ int cli_len = sizeof( cli_addr ); /* hang out until something happens */ newsockfd = accept( sockfd, (struct sockaddr *)&cli_addr, &cli_len ); if ( newsockfd > 0 ){ int len, pumpfd; char buf[256]; bzero( buf, 256 ); pumpfd = open( "/proc/pump", O_RDONLY ); if ( pumpfd < 0 ){ len = sprintf( buf,"Couldn't contact pump"); write( newsockfd, buf, len ); } else { while( (len = read( pumpfd, buf, 255 )) ){ write( newsockfd, buf, len-1 ); } } close(pumpfd); close(newsockfd); } } } 6827l5.txt0100664000204600003300000000347707700344005011462 0ustar jillljedit/************************************************** * * This program just sits around and periodically * checks port 5678 on the pumpserver. When the * current state changes, the log file is updated. * ************************************************/ #include #include #include #include #include #include #include #include #include #include "config.h" int main( int argc, char *argv[] ){ int sockfd; struct sockaddr_in srv_addr; char state[256]; char buf[256]; int len; int loop = 0; struct in_addr *ina; /* really lame configuration utility */ do_config( argc, argv ); if ( pconf.nodaemon == 0 ){ if ( fork() ){ exit(0); } loop = 1; } bzero( state, 256 ); bzero( (char *)&srv_addr, sizeof( srv_addr ) ); srv_addr.sin_family = AF_INET; ina = (struct in_addr*)&srv_addr.sin_addr.s_addr; if (inet_aton( pconf.pump_address, ina ) == 0 ){ exit(1); } srv_addr.sin_port = htons(pconf.port); do { sockfd = socket( AF_INET, SOCK_STREAM, 0); connect( sockfd, (struct sockaddr *)&srv_addr, sizeof( srv_addr )); int fd = open( pconf.logname, O_WRONLY | O_APPEND | O_CREAT, 0644 ); if ( fd > 0 ){ bzero( buf, 256 ); len = read( sockfd, buf, 255 ); if ( len ){ if ( strncmp( state, buf, len ) ){ time_t t = time(NULL); struct tm *gmt = gmtime(&t); char *at = asctime( gmt ); at[ strlen(at)-1 ] = '\0'; buf[len+1] = '\0'; strcpy( state, buf ); len = snprintf( buf, 255, "%s (%ld) %s\n", at, t, state ); write( fd, buf, len ); } } close(fd); } close(sockfd); if ( loop ){ sleep(pconf.wait); } } while( loop ); exit(0); }