summaryloggraphiclog1graphiclog2commitcommitdifftreerefseditfork
rawpatchinlineside by side (parent: cad9c23)
rawpatchinlineside by side (parent: cad9c23)
| author | Linus Torvalds<torvalds@linuxfoundation.org> | |
| Fri, 23 Nov 2007 20:10:08 +0000 (23 15:10 -0500) | ||
| committer | Linus Torvalds<torvalds@linuxfoundation.org> | |
| Fri, 23 Nov 2007 20:10:08 +0000 (23 15:10 -0500) |
177 files changed:
diff --git a/Makefileb/Makefile
--- a/Makefile
+++ b/Makefile
VERSION = 1
PATCHLEVEL = 3
-SUBLEVEL = 14
+SUBLEVEL = 15
ARCH = i386
diff --git a/arch/alpha/config.inb/arch/alpha/config.in
--- a/arch/alpha/config.in
+++ b/arch/alpha/config.in
bool 'xiafs filesystem support' CONFIG_XIA_FS n
bool 'msdos fs support' CONFIG_MSDOS_FS y
if [ "$CONFIG_MSDOS_FS" = "y" ]; then
-#bool 'umsdos: Unix like fs on top of std MSDOS FAT fs' CONFIG_UMSDOS_FS n
-comment 'Umsdos is not supported in 1.3.0: wait for 1.3.1'
+bool 'umsdos: Unix like fs on top of std MSDOS FAT fs' CONFIG_UMSDOS_FS n
fi
bool '/proc filesystem support' CONFIG_PROC_FS y
if [ "$CONFIG_INET" = "y" ]; then
return t.s[0];
}
-void die(char * str)
+void die(const char * str)
{
fprintf(stderr,"%s\n",str);
exit(1);
diff --git a/arch/i386/config.inb/arch/i386/config.in
--- a/arch/i386/config.in
+++ b/arch/i386/config.in
fi
bool 'HP PCLAN+ (27247B and 27252A) support' CONFIG_HPLAN_PLUS n
bool 'HP PCLAN (27245 and other 27xxx series) support' CONFIG_HPLAN n
- bool 'HP 10/100VG PCLAN (257X series) support' CONFIG_HP100 y
+ bool 'HP 10/100VG PCLAN (ISA, EISA, PCI) support' CONFIG_HP100 y
bool 'NE2000/NE1000 support' CONFIG_NE2000 y
bool 'SK_G16 support' CONFIG_SK_G16 n
fi
return (int) (ret & 0xff00) >> 8;
}
-char *pcibios_strerror (int error)
+const char *pcibios_strerror (int error)
{
static char buf[80];
--- a/arch/i386/kernel/setup.c
+++ b/arch/i386/kernel/setup.c
init_task.mm->brk = TASK_SIZE + (unsigned long) &_end;
for (;;) {
- if (c == ' ' && *(unsigned long *)from == *(unsigned long *)"mem=") {
+ if (c == ' ' && *(const unsigned long *)from == *(const unsigned long *)"mem=") {
memory_end = simple_strtoul(from+4, &from, 0);
if ( *from == 'K' || *from == 'k' ) {
memory_end = memory_end << 10;
int get_cpuinfo(char * buffer)
{
- char *model[2][9]={{"DX","SX","DX/2","4","SX/2","6",
+ static const char *model[2][9]={{"DX","SX","DX/2","4","SX/2","6",
"DX/2-WB","DX/4"},
{"Pentium 60/66","Pentium 90/100","3",
"4","5","6","7","8"}};
--- a/arch/i386/kernel/traps.c
+++ b/arch/i386/kernel/traps.c
#define VMALLOC_OFFSET (8*1024*1024)
#define MODULE_RANGE (8*1024*1024)
-/*static*/ void die_if_kernel(char * str, struct pt_regs * regs, long err)
+/*static*/ void die_if_kernel(const char * str, struct pt_regs * regs, long err)
{
int i;
unsigned long esp;
--- a/arch/i386/lib/checksum.c
+++ b/arch/i386/lib/checksum.c
* computes a partial checksum, e.g. for TCP/UDP fragments
*/
-unsigned int csum_partial(unsigned char * buff, int len, unsigned int sum) {
+unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum) {
/*
* Experiments with ethernet and slip connections show that buff
* is aligned on either a 2-byte or 4-byte boundary. We get at
* copy from fs while checksumming, otherwise like csum_partial
*/
-unsigned int csum_partial_copy_fromuser( char *src, char *dst,
+unsigned int csum_partial_copy_fromuser(const char *src, char *dst,
int len, int sum) {
__asm__("
testl $2, %%edi # Check alignment.
* copy from ds while checksumming, otherwise like csum_partial
*/
-unsigned int csum_partial_copy( char *src, char *dst,
+unsigned int csum_partial_copy(const char *src, char *dst,
int len, int sum) {
__asm__("
testl $2, %%edi # Check alignment.
void emu_printall()
{
int i;
- static char *tag_desc[] = { "Valid", "Zero", "ERROR", "ERROR",
+ static const char *tag_desc[] = { "Valid", "Zero", "ERROR", "ERROR",
"DeNorm", "Inf", "NaN", "Empty" };
unsigned char byte1, FPU_modrm;
unsigned long address = FPU_ORIG_EIP;
static struct {
int type;
- char *name;
+ const char *name;
} exception_names[] = {
{ EX_StackOver, "stack overflow" },
{ EX_StackUnder, "stack underflow" },
#define reg_move(x, y) { \
- *(short *)&((y)->sign) = *(short *)&((x)->sign); \
- *(long *)&((y)->exp) = *(long *)&((x)->exp); \
- *(long long *)&((y)->sigl) = *(long long *)&((x)->sigl); }
+ *(short *)&((y)->sign) = *(const short *)&((x)->sign); \
+ *(long *)&((y)->exp) = *(const long *)&((x)->exp); \
+ *(long long *)&((y)->sigl) = *(const long long *)&((x)->sigl); }
#define significand(x) ( ((unsigned long long *)&((x)->sigl))[0] )
diff --git a/arch/i386/mm/fault.cb/arch/i386/mm/fault.c
--- a/arch/i386/mm/fault.c
+++ b/arch/i386/mm/fault.c
#include <asm/segment.h>
#include <asm/pgtable.h>
-extern void die_if_kernel(char *,struct pt_regs *,long);
+extern void die_if_kernel(const char *,struct pt_regs *,long);
/*
* This routine handles page faults. It determines the address,
--- a/drivers/block/cdu31a.c
+++ b/drivers/block/cdu31a.c
outb(curr_control_reg, sony_cd_control_reg);
}
-static void
-cdu31a_interrupt(int irq, struct pt_regs *regs)
-{
- disable_interrupts();
- if (cdu31a_irq_wait != NULL)
- {
- wake_up(&cdu31a_irq_wait);
- }
- else
- {
- printk("CDU31A: Got an interrupt but nothing was waiting\n");
- }
-}
-
/*
* Wait a little while (used for polling the drive). If in initialization,
* setting a timeout doesn't work, so just loop for a while.
outb(cmd, sony_cd_cmd_reg);
}
+static void
+cdu31a_interrupt(int irq, struct pt_regs *regs)
+{
+ unsigned char val;
+
+ if (abort_read_started)
+ {
+ /* We might be waiting for an abort to finish. Don't
+ disable interrupts yet, though, because we handle
+ this one here. */
+ /* Clear out the result registers. */
+ while (is_result_reg_not_empty())
+ {
+ val = read_result_register();
+ }
+ clear_data_ready();
+ clear_result_ready();
+
+ /* Clear out the data */
+ while (is_data_requested())
+ {
+ val = read_data_register();
+ }
+ abort_read_started = 0;
+
+ /* If something was waiting, wake it up now. */
+ if (cdu31a_irq_wait != NULL)
+ {
+ disable_interrupts();
+ wake_up(&cdu31a_irq_wait);
+ }
+ }
+ else if (cdu31a_irq_wait != NULL)
+ {
+ disable_interrupts();
+ wake_up(&cdu31a_irq_wait);
+ }
+ else
+ {
+ disable_interrupts();
+ printk("CDU31A: Got an interrupt but nothing was waiting\n");
+ }
+}
+
/*
* Set the drive parameters so the drive will auto-spin-up when a
* disk is inserted.
}
static int
-do_sony_cd_cmd_chk(char *name,
+do_sony_cd_cmd_chk(const char *name,
unsigned char cmd,
unsigned char *params,
unsigned int num_params,
/* The different types of disc loading mechanisms supported */
-static char *load_mech[] = { "caddy", "tray", "pop-up", "unknown" };
+static const char *load_mech[] = { "caddy", "tray", "pop-up", "unknown" };
static void
get_drive_configuration(unsigned short base_io,
--- a/drivers/block/cm206.c
+++ b/drivers/block/cm206.c
#define ERROR -EIO
static int cm206[2] = {0,0}; /* for compatible `insmod' parameter passing */
-void parse_options()
+void parse_options(void)
{
int i;
for (i=0; i<2; i++) {
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
*/
static struct {
struct floppy_drive_params params;
- char *name; /* name printed while booting */
+ const char *name; /* name printed while booting */
} default_drive_params[]= {
/* NOTE: the time values in jiffies should be in msec!
CMOS drive type
#endif
}
-static inline void debugt(char *message)
+static inline void debugt(const char *message)
{
#ifdef DEBUGT
if ( DP->flags & DEBUGT )
static struct timer_list fd_timeout ={ NULL, NULL, 0, 0,
(timeout_fn) floppy_shutdown };
-static char *timeout_message;
+static const char *timeout_message;
#ifdef CONFIG_FLOPPY_SANITY
-static void is_alive(char *message)
+static void is_alive(const char *message)
{
/* this routine checks whether the floppy driver is "alive" */
if (fdc_busy && command_status < 2 && !fd_timeout.prev){
-static void reschedule_timeout(int drive, char *message, int marg)
+static void reschedule_timeout(int drive, const char *message, int marg)
{
if (drive == CURRENTD )
drive = current_drive;
#define COPYOUT(x) (fd_copyout( (void *)param, &(x), sizeof(x)))
#define COPYIN(x) (memcpy_fromfs( &(x), (void *) param, sizeof(x)),0)
-static char *drive_name(int type, int drive )
+static const char *drive_name(int type, int drive )
{
struct floppy_struct *floppy;
struct format_descr tmp_format_req;
int i,device,drive,type,cnt;
struct floppy_struct *this_floppy;
- char *name;
+ const char *name;
device = inode->i_rdev;
switch (cmd) {
}
static int floppy_write(struct inode * inode, struct file * filp,
- char * buf, int count)
+ const char * buf, int count)
{
int block;
int ret;
}
static struct param_table {
- char *name;
+ const char *name;
void (*fn)(int *ints, int param);
int def_param;
} config_params[]={
--- a/drivers/block/genhd.c
+++ b/drivers/block/genhd.c
* Check for Disk Manager v6.0x with geometry translation
*/
if (!tested_for_dm6++) { /* only check for DM6 *once* */
- extern int ide_xlate_1024(dev_t, int, char *);
+ extern int ide_xlate_1024(dev_t, int, const char *);
/* check for DM6 with Dynamic Drive Overlay (DDO) */
if (p->sys_ind == DM6_PARTITION) {
/*
diff --git a/drivers/block/ide.cb/drivers/block/ide.c
--- a/drivers/block/ide.c
+++ b/drivers/block/ide.c
ide_setup (str, ints);
}
-int ide_xlate_1024 (dev_t full_dev, int need_offset, char *msg)
+int ide_xlate_1024 (dev_t full_dev, int need_offset, const char *msg)
{
ide_dev_t *dev;
byte head_vals[] = {4, 8, 16, 32, 64, 128, 255, 0}, *heads = head_vals;
--- a/drivers/block/sbpcd.c
+++ b/drivers/block/sbpcd.c
static unsigned char msgnum=0;
static char msgbuf[80];
-static char *str_sb = "SoundBlaster";
-static char *str_sb_l = "soundblaster";
-static char *str_lm = "LaserMate";
-static char *str_sp = "SPEA";
-static char *str_sp_l = "spea";
-char *type;
+static const char *str_sb = "SoundBlaster";
+static const char *str_sb_l = "soundblaster";
+static const char *str_lm = "LaserMate";
+static const char *str_sp = "SPEA";
+static const char *str_sp_l = "spea";
+const char *type;
#if !(SBPCD_ISSUE-1)
-static char *major_name="sbpcd";
+static const char *major_name="sbpcd";
#endif
#if !(SBPCD_ISSUE-2)
-static char *major_name="sbpcd2";
+static const char *major_name="sbpcd2";
#endif
#if !(SBPCD_ISSUE-3)
-static char *major_name="sbpcd3";
+static const char *major_name="sbpcd3";
#endif
#if !(SBPCD_ISSUE-4)
-static char *major_name="sbpcd4";
+static const char *major_name="sbpcd4";
#endif
/*==========================================================================*/
/*
* DDI interface
*/
-static void msg(int level, char *fmt, ...)
+static void msg(int level, const char *fmt, ...)
{
char buf[256];
va_list args;
#if (SBPCD_ISSUE-1)
static
#endif
-void sbpcd_setup(char *s, int *p)
+void sbpcd_setup(const char *s, int *p)
{
setup_done++;
msg(DBG_INI,"sbpcd_setup called with %04X,%s\n",p[1], s);
}
-static int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
+static int write_mouse(struct inode * inode, struct file * file, const char * buffer, int count)
{
return -EINVAL;
}
--- a/drivers/char/busmouse.c
+++ b/drivers/char/busmouse.c
* writes are disallowed
*/
-static int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
+static int write_mouse(struct inode * inode, struct file * file, const char * buffer, int count)
{
return -EINVAL;
}
--- a/drivers/char/console.c
+++ b/drivers/char/console.c
update_attr(currcons);
}
-static void respond_string(char * p, struct tty_struct * tty)
+static void respond_string(const char * p, struct tty_struct * tty)
{
while (*p) {
tty_insert_flip_char(tty, *p, 0);
}
static int con_write(struct tty_struct * tty, int from_user,
- unsigned char *buf, int count)
+ const unsigned char *buf, int count)
{
int c, tc, ok, n = 0;
unsigned int currcons;
*/
long con_init(long kmem_start)
{
- char *display_desc = "????";
+ const char *display_desc = "????";
int currcons = 0;
int orig_x = ORIG_X;
int orig_y = ORIG_Y;
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
*/
static int
cy_write(struct tty_struct * tty, int from_user,
- unsigned char *buf, int count)
+ const unsigned char *buf, int count)
{
struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
unsigned long flags;
--- a/drivers/char/keyboard.c
+++ b/drivers/char/keyboard.c
static void do_pad(unsigned char value, char up_flag)
{
- static char *pad_chars = "0123456789+-*/\015,.?";
- static char *app_map = "pqrstuvwxylSRQMnn?";
+ static const char *pad_chars = "0123456789+-*/\015,.?";
+ static const char *app_map = "pqrstuvwxylSRQMnn?";
if (up_flag)
return; /* no action, if this is a key release */
static void do_cur(unsigned char value, char up_flag)
{
- static char *cur_chars = "BDCA";
+ static const char *cur_chars = "BDCA";
if (up_flag)
return;
diff --git a/drivers/char/lp.cb/drivers/char/lp.c
--- a/drivers/char/lp.c
+++ b/drivers/char/lp.c
wake_up(&lp->lp_wait_q);
}
-static int lp_write_interrupt(struct inode * inode, struct file * file, char * buf, int count)
+static int lp_write_interrupt(struct inode * inode, struct file * file, const char * buf, int count)
{
unsigned int minor = MINOR(inode->i_rdev);
unsigned long copy_size;
@@ -223,11+223,12 @@ static int lp_write_interrupt(struct inode * inode, struct file * file, char * b
}
static int lp_write_polled(struct inode * inode, struct file * file,
- char * buf, int count)
+ const char * buf, int count)
{
int retval;
unsigned int minor = MINOR(inode->i_rdev);
- char c, *temp = buf;
+ char c;
+ const char *temp = buf;
#ifdef LP_DEBUG
if (jiffies-lp_last_call > LP_TIME(minor)) {
return temp-buf;
}
-static int lp_write(struct inode * inode, struct file * file, char * buf, int count)
+static int lp_write(struct inode * inode, struct file * file, const char * buf, int count)
{
if (LP_IRQ(MINOR(inode->i_rdev)))
return lp_write_interrupt(inode, file, buf, count);
diff --git a/drivers/char/mem.cb/drivers/char/mem.c
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
return -EIO;
}
-static int write_ram(struct inode * inode, struct file * file,char * buf, int count)
+static int write_ram(struct inode * inode, struct file * file, const char * buf, int count)
{
return -EIO;
}
return read;
}
-static int write_mem(struct inode * inode, struct file * file,char * buf, int count)
+static int write_mem(struct inode * inode, struct file * file,const char * buf, int count)
{
unsigned long p = file->f_pos;
int written;
@@ -134,10+134,10 @@ static int read_port(struct inode * inode,struct file * file,char * buf, int cou
return tmp-buf;
}
-static int write_port(struct inode * inode,struct file * file,char * buf, int count)
+static int write_port(struct inode * inode,struct file * file,const char * buf, int count)
{
unsigned int i = file->f_pos;
- char * tmp = buf;
+ const char * tmp = buf;
while (count-- > 0 && i < 65536) {
outb(get_user(tmp),i);
return 0;
}
-static int write_null(struct inode * inode,struct file * file,char * buf, int count)
+static int write_null(struct inode * inode,struct file * file, const char * buf, int count)
{
return count;
}
return count;
}
-static int write_full(struct inode * inode,struct file * file,char * buf, int count)
+static int write_full(struct inode * inode,struct file * file, const char * buf, int count)
{
return -ENOSPC;
}
}
-static int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
+static int write_mouse(struct inode * inode, struct file * file, const char * buffer, int count)
{
return -EINVAL;
}
diff --git a/drivers/char/n_tty.cb/drivers/char/n_tty.c
--- a/drivers/char/n_tty.c
+++ b/drivers/char/n_tty.c
put_tty_queue(c, tty);
}
-static void n_tty_receive_buf(struct tty_struct *tty, unsigned char *cp,
+static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
char *fp, int count)
{
- unsigned char *p;
+ const unsigned char *p;
char *f, flags = 0;
int i;
}
static int write_chan(struct tty_struct * tty, struct file * file,
- unsigned char * buf, unsigned int nr)
+ const unsigned char * buf, unsigned int nr)
{
struct wait_queue wait = { current, NULL };
int c;
- unsigned char *b = buf;
+ const unsigned char *b = buf;
int retval = 0;
/* Job control check -- must be done at start (POSIX.1 7.1.1.4). */
diff --git a/drivers/char/psaux.cb/drivers/char/psaux.c
--- a/drivers/char/psaux.c
+++ b/drivers/char/psaux.c
* Write to the aux device.
*/
-static int write_aux(struct inode * inode, struct file * file, char * buffer, int count)
+static int write_aux(struct inode * inode, struct file * file, const char * buffer, int count)
{
int i = count;
* Write to the 82C710 mouse device.
*/
-static int write_qp(struct inode * inode, struct file * file, char * buffer, int count)
+static int write_qp(struct inode * inode, struct file * file, const char * buffer, int count)
{
int i = count;
diff --git a/drivers/char/pty.cb/drivers/char/pty.c
--- a/drivers/char/pty.c
+++ b/drivers/char/pty.c
}
static int pty_write(struct tty_struct * tty, int from_user,
- unsigned char *buf, int count)
+ const unsigned char *buf, int count)
{
struct tty_struct *to = tty->link;
int c=0, n, r;
diff --git a/drivers/char/scc.cb/drivers/char/scc.c
--- a/drivers/char/scc.c
+++ b/drivers/char/scc.c
int scc_open(struct tty_struct *tty, struct file *filp);
static void scc_close(struct tty_struct *tty, struct file *filp);
-int scc_write(struct tty_struct *tty, int from_user, unsigned char *buf, int count);
+int scc_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count);
static void scc_put_char(struct tty_struct *tty, unsigned char ch);
static void scc_flush_chars(struct tty_struct *tty);
static int scc_write_room(struct tty_struct *tty);
/* ----> tx routine: decode KISS data and scc_enqueue it <---- */
/* send raw frame to SCC. used for AX.25 */
-int scc_write(struct tty_struct *tty, int from_user, unsigned char *buf, int count)
+int scc_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count)
{
unsigned long flags;
static unsigned char *p;
--- a/drivers/char/serial.c
+++ b/drivers/char/serial.c
}
static int rs_write(struct tty_struct * tty, int from_user,
- unsigned char *buf, int count)
+ const unsigned char *buf, int count)
{
int c, total = 0;
struct async_struct *info = (struct async_struct *)tty->driver_data;
--- a/drivers/char/tpqic02.c
+++ b/drivers/char/tpqic02.c
/* This translates minor numbers to the corresponding recording format: */
-static char *format_names[] = {
+static const char *format_names[] = {
"not set", /* for dumb drives unable to handle format selection */
"11", /* extinct */
"24",
*/
static struct exception_list_type {
unsigned short mask, code;
- char *msg;
+ const char *msg;
/* EXC_nr attribute should match with tpqic02.h */
} exception_list[] = {
{0, 0,
-static void tpqputs(unsigned long flags, char *s)
+static void tpqputs(unsigned long flags, const char *s)
{
if ((flags & TPQD_ALWAYS) || (flags & QIC02_TAPE_DEBUG))
printk(TPQIC02_NAME ": %s\n", s);
@@ -2090,7+2090,7 @@ static int qic02_tape_read(struct inode * inode, struct file * filp, char * buf,
* tape device again. The driver will detect an exception status in (No Cartridge)
* and force a rewind. After that tar may continue writing.
*/
-static int qic02_tape_write(struct inode * inode, struct file * filp, char * buf, int count)
+static int qic02_tape_write(struct inode * inode, struct file * filp, const char * buf, int count)
{
int error;
dev_t dev = inode->i_rdev;
@@ -2163,7+2163,7 @@ static int qic02_tape_write(struct inode * inode, struct file * filp, char * buf
/* copy from user to DMA buffer and initiate transfer. */
if (bytes_todo>0) {
- memcpy_fromfs( (void *) buffaddr, (void *) buf, bytes_todo);
+ memcpy_fromfs( (void *) buffaddr, (const void *) buf, bytes_todo);
/****************** similar problem with read() at FM could happen here at EOT.
******************/
} /* qic02_tape_open */
-
-static int qic02_tape_readdir(struct inode * inode, struct file * filp, struct dirent * dp, int count)
-{
- return -ENOTDIR; /* not supported */
-} /* qic02_tape_readdir */
-
-
-
static void qic02_tape_release(struct inode * inode, struct file * filp)
{
dev_t dev = inode->i_rdev;
qic02_tape_lseek, /* not allowed */
qic02_tape_read, /* read */
qic02_tape_write, /* write */
- qic02_tape_readdir, /* not allowed */
+ NULL, /* readdir not allowed */
NULL, /* select ??? */
qic02_tape_ioctl, /* ioctl */
NULL, /* mmap not allowed */
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
static void initialize_tty_struct(struct tty_struct *tty);
static int tty_read(struct inode *, struct file *, char *, int);
-static int tty_write(struct inode *, struct file *, char *, int);
+static int tty_write(struct inode *, struct file *, const char *, int);
static int tty_select(struct inode *, struct file *, int, select_table *);
static int tty_open(struct inode *, struct file *);
static void tty_release(struct inode *, struct file *);
return 0;
}
-static int hung_up_tty_write(struct inode * inode, struct file * file, char * buf, int count)
+static int hung_up_tty_write(struct inode * inode, struct file * file, const char * buf, int count)
{
return -EIO;
}
return i;
}
-static int tty_write(struct inode * inode, struct file * file, char * buf, int count)
+static int tty_write(struct inode * inode, struct file * file, const char * buf, int count)
{
int i, is_console;
struct tty_struct * tty;
#endif
if (tty->ldisc.write)
/* XXX casts are for what kernel-wide prototypes should be. */
- i = (tty->ldisc.write)(tty,file,(unsigned char *)buf,(unsigned int)count);
+ i = (tty->ldisc.write)(tty,file,(const unsigned char *)buf,(unsigned int)count);
else
i = -EIO;
if (i > 0)
int retval;
struct tty_driver *p;
int found = 0;
- char *othername = NULL;
+ const char *othername = NULL;
if (*driver->refcount)
return -EBUSY;
--- a/drivers/char/vc_screen.c
+++ b/drivers/char/vc_screen.c
}
static int
-vcs_write(struct inode *inode, struct file *file, char *buf, int count)
+vcs_write(struct inode *inode, struct file *file, const char *buf, int count)
{
unsigned long p = file->f_pos;
unsigned int cons = MINOR(inode->i_rdev);
int viewed, attr, size, written;
- char *buf0;
+ const char *buf0;
unsigned short *org;
attr = (cons & 128);
org++;
}
while (count > 1) {
- scr_writew(get_user((unsigned short *) buf), org++);
+ scr_writew(get_user((const unsigned short *) buf), org++);
buf += 2;
count -= 2;
}
diff --git a/drivers/char/vt.cb/drivers/char/vt.c
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
if (!perm)
return -EPERM;
- i = verify_area(VERIFY_READ, (void *)a, sizeof(struct kbentry));
+ i = verify_area(VERIFY_READ, (const void *)a, sizeof(struct kbentry));
if (i)
return i;
if ((i = get_user(&a->kb_index)) >= NR_KEYS)
diff --git a/drivers/net/3c501.cb/drivers/net/3c501.c
--- a/drivers/net/3c501.c
+++ b/drivers/net/3c501.c
*/
-static char *version =
+static const char *version =
"3c501.c: 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov).\n";
/*
{
#ifndef MODULE
- char *mname; /* Vendor name */
+ const char *mname; /* Vendor name */
unsigned char station_addr[6];
int autoirq = 0;
int i;
diff --git a/drivers/net/3c503.cb/drivers/net/3c503.c
--- a/drivers/net/3c503.c
+++ b/drivers/net/3c503.c
The Crynwr 3c503 packet driver.
*/
-static char *version =
+static const char *version =
"3c503.c:v1.10 9/23/93 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
#include <linux/kernel.h>
diff --git a/drivers/net/3c505.cb/drivers/net/3c505.c
--- a/drivers/net/3c505.c
+++ b/drivers/net/3c505.c
*
*********************************************************/
-static char * filename = __FILE__;
+static const char * filename = __FILE__;
-static char * null_msg = "*** NULL at %s:%s (line %d) ***\n";
+static const char * null_msg = "*** NULL at %s:%s (line %d) ***\n";
#define CHECK_NULL(p) \
if (!p) printk(null_msg, filename,__FUNCTION__,__LINE__)
-static char * timeout_msg = "*** timeout at %s:%s (line %d) ***\n";
+static const char * timeout_msg = "*** timeout at %s:%s (line %d) ***\n";
#define TIMEOUT_MSG(lineno) \
printk(timeout_msg, filename,__FUNCTION__,(lineno))
-static char * invalid_pcb_msg =
+static const char * invalid_pcb_msg =
"*** invalid pcb length %d at %s:%s (line %d) ***\n";
#define INVALID_PCB_MSG(len) \
printk(invalid_pcb_msg, (len),filename,__FUNCTION__,__LINE__)
-static char * search_msg = "%s: Looking for 3c505 adapter at address %#x...";
+static const char * search_msg = "%s: Looking for 3c505 adapter at address %#x...";
-static char * stilllooking_msg = "still looking...";
+static const char * stilllooking_msg = "still looking...";
-static char * found_msg = "found.\n";
+static const char * found_msg = "found.\n";
-static char * notfound_msg = "not found (reason = %d)\n";
+static const char * notfound_msg = "not found (reason = %d)\n";
-static char * couldnot_msg = "%s: 3c505 not found\n";
+static const char * couldnot_msg = "%s: 3c505 not found\n";
/*********************************************************
*
{
int timeout;
int addr=dev->base_addr;
- char *name=dev->name;
+ const char *name=dev->name;
byte orig_HCR=inb_control(addr),
orig_HSR=inb_status(addr);
diff --git a/drivers/net/3c507.cb/drivers/net/3c507.c
--- a/drivers/net/3c507.c
+++ b/drivers/net/3c507.c
The statistics need to be updated correctly.
*/
-static char *version =
+static const char *version =
"3c507.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
#include <linux/config.h>
diff --git a/drivers/net/3c509.cb/drivers/net/3c509.c
--- a/drivers/net/3c509.c
+++ b/drivers/net/3c509.c
practice this rarely happens.
*/
-static char *version = "3c509.c:1.03 10/8/94 becker@cesdis.gsfc.nasa.gov\n";
+static const char *version = "3c509.c:1.03 10/8/94 becker@cesdis.gsfc.nasa.gov\n";
#include <linux/config.h>
#ifdef MODULE
request_region(dev->base_addr, 16,"3c509");
{
- char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
+ const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
printk("%s: 3c509 at %#3.3lx tag %d, %s port, address ",
dev->name, dev->base_addr, current_tag, if_names[dev->if_port]);
}
diff --git a/drivers/net/8390.cb/drivers/net/8390.c
--- a/drivers/net/8390.c
+++ b/drivers/net/8390.c
*/
-static char *version =
+static const char *version =
"8390.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
/*
diff --git a/drivers/net/8390.hb/drivers/net/8390.h
--- a/drivers/net/8390.h
+++ b/drivers/net/8390.h
things in there should be here!) */
/* You have one of these per-board */
struct ei_device {
- char *name;
+ const char *name;
void (*reset_8390)(struct device *);
void (*block_output)(struct device *, int, const unsigned char *, int);
int (*block_input)(struct device *, int, char *, int);
diff --git a/drivers/net/ac3200.cb/drivers/net/ac3200.c
--- a/drivers/net/ac3200.c
+++ b/drivers/net/ac3200.c
by glee@ardnassak.math.clemson.edu.
*/
-static char *version =
+static const char *version =
"ac3200.c:v1.01 7/1/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
#include <linux/kernel.h>
static unsigned char config2irqmap[8] = {15, 12, 11, 10, 9, 7, 5, 3};
static int addrmap[8] =
{0xFF0000, 0xFE0000, 0xFD0000, 0xFFF0000, 0xFFE0000, 0xFFC0000, 0xD0000, 0 };
-static char *port_name[4] = { "10baseT", "invalid", "AUI", "10base2"};
+static const char *port_name[4] = { "10baseT", "invalid", "AUI", "10base2"};
#define config2irq(configval) config2irqmap[((configval) >> 3) & 7]
#define config2mem(configval) addrmap[(configval) & 7]
--- a/drivers/net/apricot.c
+++ b/drivers/net/apricot.c
*/
-static char *version = "apricot.c:v0.2 05/12/94\n";
+static const char *version = "apricot.c:v0.2 05/12/94\n";
#ifdef MODULE
#include <linux/module.h>
diff --git a/drivers/net/arcnet.cb/drivers/net/arcnet.c
--- a/drivers/net/arcnet.c
+++ b/drivers/net/arcnet.c
<jojo@repas.de>
*/
-static char *version =
+static const char *version =
"arcnet.c:v1.92 ALPHA 95/07/11 Avery Pennarun <apenwarr@foxnet.net>\n";
/**************************************************************************/
diff --git a/drivers/net/at1700.cb/drivers/net/at1700.c
--- a/drivers/net/at1700.c
+++ b/drivers/net/at1700.c
response to inb()s from other device probes!
*/
-static char *version =
+static const char *version =
"at1700.c:v1.12 1/18/95 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
#include <linux/config.h>
0x1800 == use coax interface
*/
{
- char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
+ const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
ushort setup_value = read_eeprom(ioaddr, 12);
dev->if_port = setup_value >> 8;
diff --git a/drivers/net/atp.cb/drivers/net/atp.c
--- a/drivers/net/atp.c
+++ b/drivers/net/atp.c
The timer-based reset code was written by Bill Carlson, wwc@super.org.
*/
-static char *version =
+static const char *version =
"atp.c:v1.01 1/18/95 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
/*
diff --git a/drivers/net/de4x5.cb/drivers/net/de4x5.c
--- a/drivers/net/de4x5.c
+++ b/drivers/net/de4x5.c
=========================================================================
*/
-static char *version = "de4x5.c:v0.32 6/26/95 davies@wanton.lkg.dec.com\n";
+static const char *version = "de4x5.c:v0.32 6/26/95 davies@wanton.lkg.dec.com\n";
#include <linux/config.h>
#ifdef MODULE
static int EISA_signature(char *name, s32 eisa_id)
{
u_int i;
- char *signatures[] = DE4X5_SIGNATURE;
+ const char *signatures[] = DE4X5_SIGNATURE;
char ManCode[DE4X5_STRLEN];
union {
s32 ID;
diff --git a/drivers/net/de600.cb/drivers/net/de600.c
--- a/drivers/net/de600.c
+++ b/drivers/net/de600.c
-static char *version =
+static const char *version =
"de600.c: $Revision: 1.40 $, Bjorn Ekwall (bj0rn@blox.se)\n";
/*
* de600.c
diff --git a/drivers/net/de620.cb/drivers/net/de620.c
--- a/drivers/net/de620.c
+++ b/drivers/net/de620.c
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*****************************************************************************/
-static char *version =
+static const char *version =
"de620.c: $Revision: 1.31 $, Bjorn Ekwall <bj0rn@blox.se>\n";
\f
/***********************************************************************
diff --git a/drivers/net/depca.cb/drivers/net/depca.c
--- a/drivers/net/depca.c
+++ b/drivers/net/depca.c
=========================================================================
*/
-static char *version = "depca.c:v0.41 5/26/95 davies@wanton.lkg.dec.com\n";
+static const char *version = "depca.c:v0.41 5/26/95 davies@wanton.lkg.dec.com\n";
#include <linux/config.h>
#ifdef MODULE
static void DepcaSignature(char *name, u_long paddr)
{
u_int i,j,k;
- char *signatures[] = DEPCA_SIGNATURE;
+ const char *signatures[] = DEPCA_SIGNATURE;
char tmpstr[16];
for (i=0;i<16;i++) { /* copy the first 16 bytes of ROM to */
static int EISA_signature(char *name, s32 eisa_id)
{
u_int i;
- char *signatures[] = DEPCA_SIGNATURE;
+ const char *signatures[] = DEPCA_SIGNATURE;
char ManCode[DEPCA_STRLEN];
union {
s32 ID;
diff --git a/drivers/net/e2100.cb/drivers/net/e2100.c
--- a/drivers/net/e2100.c
+++ b/drivers/net/e2100.c
If this happens, you must power down the machine for about 30 seconds.
*/
-static char *version =
+static const char *version =
"e2100.c:v1.01 7/21/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
#include <linux/kernel.h>
diff --git a/drivers/net/eepro.cb/drivers/net/eepro.c
--- a/drivers/net/eepro.c
+++ b/drivers/net/eepro.c
*/
-static char *version =
+static const char *version =
"eepro.c: v0.07a 6/5/95 Bao C. Ha (bao@saigon.async.com)\n";
/* Always include 'config.h' first in case the user wants to turn on
int i;
int eepro; /* a flag, TRUE=1 for the EtherExpress Pro/10,
FALSE = 0 for other 82595-based lan cards. */
- char *ifmap[] = {"AUI", "10Base2", "10BaseT"};
+ const char *ifmap[] = {"AUI", "10Base2", "10BaseT"};
enum iftype { AUI=0, BNC=1, TPE=2 };
/* Now, we are going to check for the signature of the
--- a/drivers/net/eexpress.c
+++ b/drivers/net/eexpress.c
Changed to support io= irq= by Alan Cox <Alan.Cox@linux.org>
*/
-static char *version =
+static const char *version =
"eexpress.c:v0.07 1/19/94 Donald Becker (becker@super.org)\n";
#include <linux/config.h>
interface to minimize bogus bug reports. */
{
char irqmap[] = {0, 9, 3, 4, 5, 10, 11, 0};
- char *ifmap[] = {"AUI", "BNC", "10baseT"};
+ const char *ifmap[] = {"AUI", "BNC", "10baseT"};
enum iftype {AUI=0, BNC=1, TP=2};
unsigned short setupval = read_eeprom(ioaddr, 0);
diff --git a/drivers/net/eql.cb/drivers/net/eql.c
--- a/drivers/net/eql.c
+++ b/drivers/net/eql.c
* Phone: 1-703-847-0040 ext 103
*/
-static char *version =
+static const char *version =
"Equalizer: $Revision: 3.12 $ $Date: 1995/01/19 $ Simon Janes (simon@ncm.com)\n";
#include <linux/config.h>
diff --git a/drivers/net/ewrk3.cb/drivers/net/ewrk3.c
--- a/drivers/net/ewrk3.c
+++ b/drivers/net/ewrk3.c
=========================================================================
*/
-static char *version = "ewrk3.c:v0.32 1/16/95 davies@wanton.lkg.dec.com\n";
+static const char *version = "ewrk3.c:v0.32 1/16/95 davies@wanton.lkg.dec.com\n";
#ifdef MODULE
#include <linux/module.h>
--- a/drivers/net/hp-plus.c
+++ b/drivers/net/hp-plus.c
programming information.
*/
-static char *version =
+static const char *version =
"hp-plus.c:v1.10 9/24/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
#include <linux/string.h> /* Important -- this inlines word moves. */
{
int i;
unsigned char checksum = 0;
- char *name = "HP-PC-LAN+";
+ const char *name = "HP-PC-LAN+";
int mem_start;
/* Check for the HP+ signature, 50 48 0x 53. */
diff --git a/drivers/net/hp.cb/drivers/net/hp.c
--- a/drivers/net/hp.c
+++ b/drivers/net/hp.c
The Crynwr packet driver.
*/
-static char *version =
+static const char *version =
"hp.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
#include <linux/kernel.h>
int hp_probe1(struct device *dev, int ioaddr)
{
int i, board_id, wordmode;
- char *name;
+ const char *name;
/* Check for the HP physical address, 08 00 09 xx xx xx. */
/* This really isn't good enough: we may pick up HP LANCE boards
diff --git a/drivers/net/hp100.cb/drivers/net/hp100.c
--- a/drivers/net/hp100.c
+++ b/drivers/net/hp100.c
* HP 27248B 10 only EISA card with Cascade chip
* HP J2577 10/100 EISA card with Cascade chip
* HP J2573 10/100 ISA card with Cascade chip
+ * HP J2585 10/100 PCI card
*
* Other ATT2MD01 Chip based boards might be supported in the future
* (there are some minor changes needed).
* TO DO:
* ======
* - ioctl handling - some runtime setup things
- * - PCI card support
+ * - high priority communications support
+ * - memory mapped access support for PCI cards
*
* Revision history:
* =================
* Little bug in hp100_close function fixed.
* 100Mb/s connection debugged.
* 0.12 14-Jul-95 Link down is now handled better.
+ * 0.20 01-Aug-95 Added PCI support for HP J2585A card.
+ * Statistics bug fixed.
*
*/
#include <linux/ioport.h>
#include <linux/malloc.h>
#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/bios32.h>
#include <asm/bitops.h>
#include <asm/io.h>
* defines
*/
+#define HP100_BUS_ISA 0
+#define HP100_BUS_EISA 1
+#define HP100_BUS_PCI 2
+
+#define HP100_REGION_SIZE 0x20
+
#define HP100_MAX_PACKET_SIZE (1536+4)
#define HP100_MIN_PACKET_SIZE 60
struct hp100_eisa_id {
u_int id;
- char *name;
+ const char *name;
+ u_char bus;
};
struct hp100_private {
u_short soft_model;
u_int memory_size;
u_short rx_ratio;
+ short mem_mapped; /* memory mapped access */
+ u_char *mem_ptr; /* pointer to memory mapped area */
short lan_type; /* 10Mb/s, 100Mb/s or -1 (error) */
- int hub_status; /* login to hub successfull? */
+ int hub_status; /* login to hub was successfull? */
u_char mac1_mode;
u_char mac2_mode;
struct enet_statistics stats;
};
-struct hp100_rx_look {
- struct hp100_rx_header header;
- char something[ 24 ]; /* 2 * MAC @6 + protocol @2+8 + pad to 4 byte */
-};
-
/*
* variables
*/
static struct hp100_eisa_id hp100_eisa_ids[] = {
- { 0x080F1F022, "HP J2577 rev A" }, /* 10/100 EISA card with REVA Cascade chip */
- { 0x050F1F022, "HP J2573 rev A" }, /* 10/100 ISA card with REVA Cascade chip */
- { 0x02019F022, "HP 27248B" }, /* 10 only EISA card with Cascade chip */
- { 0x04019F022, "HP J2577" }, /* 10/100 EISA card with Cascade chip */
- { 0x05019F022, "HP J2573" } /* 10/100 ISA card with Cascade chip */
+
+ /* 10/100 EISA card with REVA Cascade chip */
+ { 0x080F1F022, "HP J2577 rev A", HP100_BUS_EISA },
+
+ /* 10/100 ISA card with REVA Cascade chip */
+ { 0x050F1F022, "HP J2573 rev A", HP100_BUS_ISA },
+
+ /* 10 only EISA card with Cascade chip */
+ { 0x02019F022, "HP 27248B", HP100_BUS_EISA },
+
+ /* 10/100 EISA card with Cascade chip */
+ { 0x04019F022, "HP J2577", HP100_BUS_EISA },
+
+ /* 10/100 ISA card with Cascade chip */
+ { 0x05019F022, "HP J2573", HP100_BUS_ISA },
+
+ /* 10/100 PCI card */
+ /* Note: ID for this card is same as PCI vendor/device numbers. */
+ { 0x01030103c, "HP J2585", HP100_BUS_PCI },
};
#ifdef MODULE
* prototypes
*/
-static int hp100_probe1( struct device *dev, int ioaddr );
+static int hp100_probe1( struct device *dev, int ioaddr, int bus );
static int hp100_open( struct device *dev );
static int hp100_close( struct device *dev );
static int hp100_start_xmit( struct sk_buff *skb, struct device *dev );
static void hp100_rx( struct device *dev );
static struct enet_statistics *hp100_get_stats( struct device *dev );
static void hp100_update_stats( struct device *dev );
+static void hp100_clear_stats( int ioaddr );
#ifdef HAVE_MULTICAST
static void hp100_set_multicast_list( struct device *dev, int num_addrs, void *addrs );
#endif
-#ifndef LINUX_1_1_52
static void hp100_interrupt( int irq, struct pt_regs *regs );
-#else
-static void hp100_interrupt( int irq );
-#endif
static void hp100_start_interface( struct device *dev );
static void hp100_stop_interface( struct device *dev );
{
int base_addr = dev ? dev -> base_addr : 0;
int ioaddr;
-
+#ifdef CONFIG_PCI
+ int pci_start_index = 0;
+#endif
+
if ( base_addr > 0xff ) /* Check a single specified location. */
- return hp100_probe1(dev, base_addr);
+ {
+ if ( check_region( base_addr, HP100_REGION_SIZE ) ) return -EINVAL;
+ if ( base_addr < 0x400 )
+ return hp100_probe1( dev, base_addr, HP100_BUS_ISA );
+ else
+ return hp100_probe1( dev, base_addr, HP100_BUS_EISA );
+ }
else
+#ifdef CONFIG_PCI
+ if ( base_addr > 0 && base_addr < 8 + 1 )
+ pci_start_index = 0x100 | ( base_addr - 1 );
+ else
+#endif
if ( base_addr != 0 ) return -ENXIO;
+
+ /* at first - scan PCI bus(es) */
+
+#ifdef CONFIG_PCI
+ if ( pcibios_present() )
+ {
+ int pci_index;
+
+#ifdef HP100_DEBUG_PCI
+ printk( "hp100: PCI BIOS is present, checking for devices..\n" );
+#endif
+ for ( pci_index = pci_start_index & 7; pci_index < 8; pci_index++ )
+ {
+ u_char pci_bus, pci_device_fn;
+ u_short pci_command;
+
+ if ( pcibios_find_device( PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585A,
+ pci_index, &pci_bus,
+ &pci_device_fn ) != 0 ) break;
+ pcibios_read_config_dword( pci_bus, pci_device_fn,
+ PCI_BASE_ADDRESS_0, &ioaddr );
+
+ ioaddr &= ~3; /* remove I/O space marker in bit 0. */
+
+ if ( check_region( ioaddr, HP100_REGION_SIZE ) ) continue;
+
+ pcibios_read_config_word( pci_bus, pci_device_fn,
+ PCI_COMMAND, &pci_command );
+ if ( !( pci_command & PCI_COMMAND_MASTER ) )
+ {
+#ifdef HP100_DEBUG_PCI
+ printk( "hp100: PCI Master Bit has not been set. Setting...\n" );
+#endif
+ pci_command |= PCI_COMMAND_MASTER;
+ pcibios_write_config_word( pci_bus, pci_device_fn,
+ PCI_COMMAND, pci_command );
+ }
+#ifdef HP100_DEBUG_PCI
+ printk( "hp100: PCI adapter found at 0x%x\n", ioaddr );
+#endif
+ if ( hp100_probe1( dev, ioaddr, HP100_BUS_PCI ) == 0 ) return 0;
+ }
+ }
+ if ( pci_start_index > 0 ) return -ENODEV;
+#endif /* CONFIG_PCI */
- /* at first - probe all EISA possible port regions (if EISA bus present) */
+ /* at second - probe all EISA possible port regions (if EISA bus present) */
for ( ioaddr = 0x1c38; EISA_bus && ioaddr < 0x10000; ioaddr += 0x400 )
{
- if ( check_region( ioaddr, 0x20 ) ) continue;
- if ( hp100_probe1( dev, ioaddr ) == 0 ) return 0;
+ if ( check_region( ioaddr, HP100_REGION_SIZE ) ) continue;
+ if ( hp100_probe1( dev, ioaddr, HP100_BUS_EISA ) == 0 ) return 0;
}
- /* at second - probe all ISA possible port regions */
+ /* at third - probe all ISA possible port regions */
for ( ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20 )
{
- if ( check_region( ioaddr, 0x20 ) ) continue;
- if ( hp100_probe1( dev, ioaddr ) == 0 ) return 0;
+ if ( check_region( ioaddr, HP100_REGION_SIZE ) ) continue;
+ if ( hp100_probe1( dev, ioaddr, HP100_BUS_ISA ) == 0 ) return 0;
}
return -ENODEV;
}
-static int hp100_probe1( struct device *dev, int ioaddr )
+static int hp100_probe1( struct device *dev, int ioaddr, int bus )
{
int i;
- u_char uc;
+ u_char uc, uc_1;
u_int eisa_id;
+ short mem_mapped;
+ u_char *mem_ptr;
struct hp100_private *lp;
struct hp100_eisa_id *eid;
return EIO;
}
- if ( inb( ioaddr + 0 ) != HP100_HW_ID_0 ||
- inb( ioaddr + 1 ) != HP100_HW_ID_1 ||
- ( inb( ioaddr + 2 ) & 0xf0 ) != HP100_HW_ID_2_REVA ||
- inb( ioaddr + 3 ) != HP100_HW_ID_3 )
- return -ENODEV;
+ if ( bus != HP100_BUS_PCI ) /* don't check PCI cards again */
+ if ( inb( ioaddr + 0 ) != HP100_HW_ID_0 ||
+ inb( ioaddr + 1 ) != HP100_HW_ID_1 ||
+ ( inb( ioaddr + 2 ) & 0xf0 ) != HP100_HW_ID_2_REVA ||
+ inb( ioaddr + 3 ) != HP100_HW_ID_3 )
+ return -ENODEV;
dev -> base_addr = ioaddr;
for ( i = uc = eisa_id = 0; i < 4; i++ )
{
eisa_id >>= 8;
- eisa_id |= ( hp100_inb( BOARD_ID + i ) ) << 24;
- uc += eisa_id >> 24;
+ uc_1 = hp100_inb( BOARD_ID + i );
+ eisa_id |= uc_1 << 24;
+ uc += uc_1;
}
uc += hp100_inb( BOARD_ID + 4 );
break;
if ( i >= sizeof( hp100_eisa_ids ) / sizeof( struct hp100_eisa_id ) )
{
- printk( "hp100_probe1: card at port 0x%x isn't known\n", ioaddr );
+ printk( "hp100_probe1: card at port 0x%x isn't known (id = 0x%x)\n", ioaddr, eisa_id );
return -ENODEV;
}
eid = &hp100_eisa_ids[ i ];
return -EIO;
}
+#ifndef HP100_IO_MAPPED
hp100_page( HW_MAP );
- if ( hp100_inw( OPTION_LSW ) & ( HP100_MEM_EN | HP100_BM_WRITE | HP100_BM_READ ) )
+ mem_mapped = ( hp100_inw( OPTION_LSW ) &
+ ( HP100_MEM_EN | HP100_BM_WRITE | HP100_BM_READ ) ) != 0;
+ mem_ptr = NULL;
+ if ( mem_mapped )
{
- printk( "hp100_probe1: memory mapped io isn't supported (card %s at port 0x%x)\n",
- eid -> name, ioaddr );
- return -EIO;
+ mem_ptr = (u_char *)( hp100_inw( MEM_MAP_LSW ) |
+ ( hp100_inw( MEM_MAP_MSW ) << 16 ) );
+ (u_int)mem_ptr &= ~0x1fff; /* 8k aligment */
+ if ( bus == HP100_BUS_ISA && ( (u_int)mem_ptr & ~0xfffff ) != 0 )
+ {
+ mem_ptr = NULL;
+ mem_mapped = 0;
+ }
+ if ( mem_mapped && bus == HP100_BUS_PCI )
+ {
+#if 0
+ printk( "writeb !!!\n" );
+ writeb( 0, mem_ptr );
+#endif
+ mem_ptr = NULL;
+ mem_mapped = 0;
+ }
}
+#else
+ mem_mapped = 0;
+ mem_ptr = NULL;
+#endif
if ( ( dev -> priv = kmalloc( sizeof( struct hp100_private ), GFP_KERNEL ) ) == NULL )
return -ENOMEM;
lp = (struct hp100_private *)dev -> priv;
lp -> id = eid;
+ lp -> mem_mapped = mem_mapped;
+ lp -> mem_ptr = mem_ptr;
hp100_page( ID_MAC_ADDR );
lp -> soft_model = hp100_inb( SOFT_MODEL );
lp -> mac1_mode = HP100_MAC1MODE3;
dev -> set_multicast_list = &hp100_set_multicast_list;
#endif
-#ifndef LINUX_1_1_52
- request_region( dev -> base_addr, 0x20, eid -> name );
-#endif
+ request_region( dev -> base_addr, HP100_REGION_SIZE, eid -> name );
hp100_page( ID_MAC_ADDR );
for ( i = uc = 0; i < 6; i++ )
dev -> dev_addr[ i ] = hp100_inb( LAN_ADDR + i );
+ hp100_clear_stats( ioaddr );
+
ether_setup( dev );
lp -> lan_type = hp100_sense_lan( dev );
- printk( "%s: %s at 0x%x, IRQ %d, %dkB SRAM (rx/tx %d%%), ",
- dev -> name, lp -> id -> name, ioaddr, dev -> irq,
+ printk( "%s: %s at 0x%x, IRQ %d, ",
+ dev -> name, lp -> id -> name, ioaddr, dev -> irq );
+ switch ( bus ) {
+ case HP100_BUS_EISA: printk( "EISA" ); break;
+ case HP100_BUS_PCI: printk( "PCI" ); break;
+ default: printk( "ISA" ); break;
+ }
+ printk( " bus, %dk SRAM (rx/tx %d%%).\n",
lp -> memory_size >> ( 10 - 4 ), lp -> rx_ratio );
+ if ( mem_mapped )
+ printk( "%s: Memory mapped access used at 0x%x-0x%x.\n",
+ dev -> name, (u_int)mem_ptr, (u_int)mem_ptr + 0x1fff );
+ printk( "%s: ", dev -> name );
+ if ( lp -> lan_type != HP100_LAN_ERR )
+ printk( "Adapter is attached to " );
switch ( lp -> lan_type ) {
- case HP100_LAN_100: printk( "100Mb/s VG TP" ); break;
- case HP100_LAN_10: printk( "10Mb/s TP" ); break;
- default: printk( "link down" ); break;
+ case HP100_LAN_100:
+ printk( "100Mb/s Voice Grade AnyLAN network.\n" );
+ break;
+ case HP100_LAN_10:
+ printk( "10Mb/s network.\n" );
+ break;
+ default:
+ printk( "Warning! Link down.\n" );
}
- printk( ".\n" );
-
+
+ hp100_stop_interface( dev );
+
return 0;
}
lp -> mac2_mode = HP100_MAC2MODE3;
hp100_page( MAC_CTRL );
- hp100_orw( HP100_LINK_BEAT_DIS, LAN_CFG_10 );
+ hp100_orw( HP100_LINK_BEAT_DIS | HP100_RESET_LB, LAN_CFG_10 );
hp100_stop_interface( dev );
- hp100_reset_card();
hp100_load_eeprom( dev );
hp100_outw( HP100_MMAP_DIS | HP100_SET_HB |
#else
hp100_outw( HP100_ADV_NXT_PKT | HP100_TX_CMD | HP100_RESET_LB, OPTION_MSW );
#endif
-
+
hp100_page( MAC_ADDRESS );
for ( i = 0; i < 6; i++ )
hp100_outb( dev -> dev_addr[ i ], MAC_ADDR + i );
hp100_outb( 0xff, HASH_BYTE0 + i );
hp100_page( PERFORMANCE );
hp100_outw( 0xfefe, IRQ_MASK ); /* mask off all ints */
- hp100_outw( 0xffff, IRQ_STATUS ); /* ack */
+ hp100_outw( 0xffff, IRQ_STATUS ); /* ack IRQ */
hp100_outw( (HP100_RX_PACKET | HP100_RX_ERROR | HP100_SET_HB) |
(HP100_TX_ERROR | HP100_SET_LB ), IRQ_MASK );
/* and enable few */
printk( "hp100_start_xmit: busy\n" );
#endif
}
-
+
hp100_ints_off();
val = hp100_inw( IRQ_STATUS );
hp100_outw( val & HP100_TX_COMPLETE, IRQ_STATUS );
#ifdef HP100_DEBUG_TX
printk( "hp100_start_xmit: irq_status = 0x%x, len = %d\n", val, (int)skb -> len );
#endif
- if ( skb -> len >= HP100_MIN_PACKET_SIZE )
+ if ( lp -> mem_mapped )
{
- hp100_outw( skb -> len, DATA32 ); /* length to memory manager */
- hp100_outw( skb -> len, FRAGMENT_LEN );
- outsl( ioaddr + HP100_REG_DATA32, skb -> data, ( skb -> len + 3 ) >> 2 );
- hp100_outw( HP100_TX_CMD | HP100_SET_LB, OPTION_MSW ); /* send packet */
+ if ( skb -> len >= HP100_MIN_PACKET_SIZE )
+ {
+ hp100_outw( skb -> len, DATA32 ); /* length to memory manager */
+ hp100_outw( skb -> len, FRAGMENT_LEN );
+ memcpy_toio( lp -> mem_ptr, skb -> data, skb -> len );
+ }
+ else
+ {
+ hp100_outw( HP100_MIN_PACKET_SIZE, DATA32 ); /* length to memory manager */
+ hp100_outw( HP100_MIN_PACKET_SIZE, FRAGMENT_LEN );
+ memcpy_toio( lp -> mem_ptr, skb -> data, skb -> len );
+ memset_io( lp -> mem_ptr, 0, HP100_MIN_PACKET_SIZE - skb -> len );
+ }
}
else
{
- hp100_outw( HP100_MIN_PACKET_SIZE, DATA32 ); /* length to memory manager */
- hp100_outw( HP100_MIN_PACKET_SIZE, FRAGMENT_LEN );
- i = skb -> len + 3;
- outsl( ioaddr + HP100_REG_DATA32, skb -> data, i >> 2 );
- for ( i &= ~3; i < HP100_MIN_PACKET_SIZE; i += 4 )
- hp100_outl( 0, DATA32 );
- hp100_outw( HP100_TX_CMD | HP100_SET_LB, OPTION_MSW ); /* send packet */
+ if ( skb -> len >= HP100_MIN_PACKET_SIZE )
+ {
+ hp100_outw( skb -> len, DATA32 ); /* length to memory manager */
+ hp100_outw( skb -> len, FRAGMENT_LEN );
+ outsl( ioaddr + HP100_REG_DATA32, skb -> data, ( skb -> len + 3 ) >> 2 );
+ }
+ else
+ {
+ hp100_outw( HP100_MIN_PACKET_SIZE, DATA32 ); /* length to memory manager */
+ hp100_outw( HP100_MIN_PACKET_SIZE, FRAGMENT_LEN );
+ i = skb -> len + 3;
+ outsl( ioaddr + HP100_REG_DATA32, skb -> data, i >> 2 );
+ for ( i &= ~3; i < HP100_MIN_PACKET_SIZE; i += 4 )
+ hp100_outl( 0, DATA32 );
+ }
}
+ hp100_outw( HP100_TX_CMD | HP100_SET_LB, OPTION_MSW ); /* send packet */
lp -> stats.tx_packets++;
dev -> trans_start = jiffies;
hp100_ints_on();
printk( "hp100_rx: busy, remaining packets = %d\n", packets );
#endif
}
- header = hp100_inl( DATA32 );
+ header = lp -> mem_mapped ? readl( lp -> mem_ptr ) : hp100_inl( DATA32 );
pkt_len = header & HP100_PKT_LEN_MASK;
#ifdef HP100_DEBUG_RX
printk( "hp100_rx: new packet - length = %d, errors = 0x%x, dest = 0x%x\n",
* allocating more than asked (notably, aligning the request up to
* the next 16-byte length).
*/
- skb = dev_alloc_skb(pkt_len);
+ skb = dev_alloc_skb( pkt_len );
if ( skb == NULL )
{
#ifdef HP100_DEBUG
}
else
{
+ u_char *ptr;
+
skb -> dev = dev;
- insl( ioaddr + HP100_REG_DATA32, skb_put(skb, pkt_len), ( pkt_len + 3 ) >> 2 );
- skb->protocol=eth_type_trans(skb,dev);
+ ptr = (u_char *)skb_put( skb, pkt_len );
+ if ( lp -> mem_mapped )
+ memcpy_fromio( ptr, lp -> mem_ptr, ( pkt_len + 3 ) & ~3 );
+ else
+ insl( ioaddr + HP100_REG_DATA32, ptr, ( pkt_len + 3 ) >> 2 );
+ skb -> protocol = eth_type_trans( skb, dev );
netif_rx( skb );
lp -> stats.rx_packets++;
+#ifdef HP100_DEBUG_RX
+ printk( "rx: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
+ ptr[ 0 ], ptr[ 1 ], ptr[ 2 ], ptr[ 3 ], ptr[ 4 ], ptr[ 5 ],
+ ptr[ 6 ], ptr[ 7 ], ptr[ 8 ], ptr[ 9 ], ptr[ 10 ], ptr[ 11 ] );
+#endif
}
hp100_outw( HP100_ADV_NXT_PKT | HP100_SET_LB, OPTION_MSW );
switch ( header & 0x00070000 ) {
hp100_page( PERFORMANCE );
}
+static void hp100_clear_stats( int ioaddr )
+{
+ cli();
+ hp100_page( MAC_CTRL ); /* get all statistics bytes */
+ hp100_inw( DROPPED );
+ hp100_inb( CRC );
+ hp100_inb( ABORT );
+ hp100_page( PERFORMANCE );
+ sti();
+}
+
/*
* multicast setup
*/
#ifdef HP100_DEBUG_MULTI
printk( "hp100_set_multicast_list: num_addrs = %d\n", num_addrs );
#endif
- hp100_ints_off();
cli();
+ hp100_ints_off();
hp100_page( MAC_CTRL );
hp100_andb( ~(HP100_RX_EN | HP100_TX_EN), MAC_CFG_1 ); /* stop rx/tx */
@@ -711,13+876,12 @@ static void hp100_set_multicast_list( struct device *dev, int num_addrs, void *a
hp100_outb( lp -> mac2_mode, MAC_CFG_2 );
hp100_andb( HP100_MAC1MODEMASK, MAC_CFG_1 );
- hp100_orb( lp -> mac1_mode, MAC_CFG_1 );
-
- hp100_orb( HP100_RX_EN | HP100_RX_IDLE, MAC_CFG_1 ); /* enable rx */
- hp100_orb( HP100_TX_EN | HP100_TX_IDLE, MAC_CFG_1 ); /* enable tx */
+ hp100_orb( lp -> mac1_mode |
+ HP100_RX_EN | HP100_RX_IDLE | /* enable rx */
+ HP100_TX_EN | HP100_TX_IDLE, MAC_CFG_1 ); /* enable tx */
hp100_page( PERFORMANCE );
- sti();
hp100_ints_on();
+ sti();
}
#endif /* HAVE_MULTICAST */
@@ -726,11+890,7 @@ static void hp100_set_multicast_list( struct device *dev, int num_addrs, void *a
* hardware interrupt handling
*/
-#ifndef LINUX_1_1_52
static void hp100_interrupt( int irq, struct pt_regs *regs )
-#else
-static void hp100_interrupt( int irq )
-#endif
{
struct device *dev = (struct device *)irq2dev_map[ irq ];
struct hp100_private *lp;
int ioaddr = dev -> base_addr;
struct hp100_private *lp = (struct hp100_private *)dev -> priv;
- hp100_unreset_card();
cli();
+ hp100_unreset_card();
hp100_page( MAC_CTRL );
hp100_outb( lp -> mac2_mode, MAC_CFG_2 );
hp100_andb( HP100_MAC1MODEMASK, MAC_CFG_1 );
- hp100_orb( lp -> mac1_mode, MAC_CFG_1 );
- hp100_orb( HP100_RX_EN | HP100_RX_IDLE, MAC_CFG_1 );
- hp100_orb( HP100_TX_EN | HP100_TX_IDLE, MAC_CFG_1 );
+ hp100_orb( lp -> mac1_mode |
+ HP100_RX_EN | HP100_RX_IDLE |
+ HP100_TX_EN | HP100_TX_IDLE, MAC_CFG_1 );
hp100_page( PERFORMANCE );
hp100_outw( HP100_INT_EN | HP100_SET_LB, OPTION_LSW );
hp100_outw( HP100_TRI_INT | HP100_RESET_HB, OPTION_LSW );
+ if ( lp -> mem_mapped )
+ {
+ /* enable memory mapping */
+ hp100_outw( HP100_MMAP_DIS | HP100_RESET_HB, OPTION_LSW );
+ }
sti();
}
u_short val;
hp100_outw( HP100_INT_EN | HP100_RESET_LB |
- HP100_TRI_INT | HP100_SET_HB, OPTION_LSW );
+ HP100_TRI_INT | HP100_MMAP_DIS | HP100_SET_HB, OPTION_LSW );
val = hp100_inw( OPTION_LSW );
hp100_page( HW_MAP );
hp100_andb( HP100_BM_SLAVE, BM );
void cleanup_module( void )
{
unregister_netdev( &dev_hp100 );
- release_region( dev_hp100.base_addr, 0x20 );
+ release_region( dev_hp100.base_addr, HP100_REGION_SIZE );
kfree_s( dev_hp100.priv, sizeof( struct hp100_private ) );
dev_hp100.priv = NULL;
}
diff --git a/drivers/net/ibmtr.cb/drivers/net/ibmtr.c
--- a/drivers/net/ibmtr.c
+++ b/drivers/net/ibmtr.c
*/
/*
- Changes by Peter De Schrijver (stud11@cc4.kuleuven.ac.be) :
+ Changes by Peter De Schrijver (Peter.Deschrijver@linux.cc.kuleuven.ac.be) :
+ changed name to ibmtr.c in anticipation of other tr boards.
+ changed reset code and adapter open code.
#define FALSE 0
#define TRUE (!FALSE)
-static char *version = "ibmtr.c:v1.1.48 8/7/94 Peter De Schrijver and Mark Swanson\n"
+static const char *version = "ibmtr.c:v1.1.48 8/7/94 Peter De Schrijver and Mark Swanson\n"
" modified 10/3/94 David W. Morris\n";
static char pcchannelid[]={0x05, 0x00, 0x04, 0x09,
/* This routine combined with the #DEFINE DPRINTD serves
to workaround the gcc apparent bug. in tr_tx() */
-static void DummyCall(char * fmt,...) {DummyCallCount++;return;}
+static void DummyCall(const char * fmt,...) {DummyCallCount++;return;}
static void PrtChanID(char *pcid, short stride) {
short i, j;
diff --git a/drivers/net/lance.cb/drivers/net/lance.c
--- a/drivers/net/lance.c
+++ b/drivers/net/lance.c
Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
*/
-static char *version = "lance.c:v1.08 4/10/95 dplatt@3do.com\n";
+static const char *version = "lance.c:v1.08 4/10/95 dplatt@3do.com\n";
#include <linux/config.h>
#include <linux/kernel.h>
struct lance_rx_head rx_ring[RX_RING_SIZE];
struct lance_tx_head tx_ring[TX_RING_SIZE];
struct lance_init_block init_block;
- char *name;
+ const char *name;
/* The saved address of a sent-in-place packet/buffer, for skfree(). */
struct sk_buff* tx_skbuff[TX_RING_SIZE];
long rx_buffs; /* Address of Rx and Tx buffers. */
reportedly has the same ID as the '965. */
static struct lance_chip_type {
int id_number;
- char *name;
+ const char *name;
int flags;
} chip_table[] = {
{0x0000, "LANCE 7990", /* Ancient lance chip. */
struct lance_private *lp;
short dma_channels; /* Mark spuriously-busy DMA channels */
int i, reset_val, lance_version;
- char *chipname;
+ const char *chipname;
/* Flags for specific chips or boards. */
unsigned char hpJ2405A = 0; /* HP ISA adaptor */
int hp_builtin = 0; /* HP on-board ethernet. */
diff --git a/drivers/net/ne.cb/drivers/net/ne.c
--- a/drivers/net/ne.c
+++ b/drivers/net/ne.c
/* Routines for the NatSemi-based designs (NE[12]000). */
-static char *version =
+static const char *version =
"ne.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
#include <linux/kernel.h>
#ifdef CONFIG_NE_BAD_CLONES
/* A list of bad clones that we none-the-less recognize. */
-static struct { char *name8, *name16; unsigned char SAprefix[4];}
+static struct { const char *name8, *name16; unsigned char SAprefix[4];}
bad_clone_list[] = {
{"DE100", "DE200", {0x00, 0xDE, 0x01,}},
{"DE120", "DE220", {0x00, 0x80, 0xc8,}},
int i;
unsigned char SA_prom[32];
int wordlength = 2;
- char *name = NULL;
+ const char *name = NULL;
int start_page, stop_page;
int neX000, ctron;
int reg0 = inb_p(ioaddr);
diff --git a/drivers/net/pi2.cb/drivers/net/pi2.c
--- a/drivers/net/pi2.c
+++ b/drivers/net/pi2.c
struct device *init_etherdev(struct device *dev, int sizeof_private,
unsigned long *mem_startp);
-static char *version =
+static const char *version =
"PI: V0.8 ALPHA April 23 1995 David Perry (dp@hydra.carleton.ca)\n";
/* The following #define is only really required for the PI card, not
diff --git a/drivers/net/plip.cb/drivers/net/plip.c
--- a/drivers/net/plip.c
+++ b/drivers/net/plip.c
* So, this PLIP can't communicate the PLIP of Linux v1.0.
*/
-static char *version = "NET3 PLIP version 2.0 gniibe@mri.co.jp\n";
+static const char *version = "NET3 PLIP version 2.0 gniibe@mri.co.jp\n";
/*
Sources:
diff --git a/drivers/net/ppp.cb/drivers/net/ppp.c
--- a/drivers/net/ppp.c
+++ b/drivers/net/ppp.c
static void ppp_unlock(struct ppp *);
static void ppp_add_fcs(struct ppp *);
static int ppp_check_fcs(struct ppp *);
-static void ppp_print_buffer(const char *,char *,int,int);
+static void ppp_print_buffer(const char *,const char *,int,int);
static int ppp_read(struct tty_struct *, struct file *, unsigned char *,
unsigned int);
-static int ppp_write(struct tty_struct *, struct file *, unsigned char *,
+static int ppp_write(struct tty_struct *, struct file *, const unsigned char *,
unsigned int);
static int ppp_ioctl(struct tty_struct *, struct file *, unsigned int,
unsigned long);
#ifdef NEW_TTY_DRIVERS
static int ppp_receive_room(struct tty_struct *tty);
-static void ppp_receive_buf(struct tty_struct *tty, unsigned char *cp,
+static void ppp_receive_buf(struct tty_struct *tty, const unsigned char *cp,
char *fp, int count);
static void ppp_write_wakeup(struct tty_struct *tty);
#else
}
-static void ppp_receive_buf(struct tty_struct *tty, unsigned char *cp,
+static void ppp_receive_buf(struct tty_struct *tty, const unsigned char *cp,
char *fp, int count)
{
register struct ppp *ppp = ppp_find (tty);
*/
static int
-ppp_write(struct tty_struct *tty, struct file *file, unsigned char *buf, unsigned int nr)
+ppp_write(struct tty_struct *tty, struct file *file, const unsigned char *buf, unsigned int nr)
{
struct ppp *ppp = ppp_find(tty);
int i;
static char hex[] = "0123456789ABCDEF";
-static inline void ppp_print_hex (register char *out, char *in, int count)
+static inline void ppp_print_hex (register char *out, const char *in, int count)
{
register unsigned char next_ch;
}
}
-static inline void ppp_print_char (register char *out, char *in, int count)
+static inline void ppp_print_char (register char *out, const char *in, int count)
{
register unsigned char next_ch;
*out = '\0';
}
-static void ppp_print_buffer(const char *name, char *buf, int count, int seg)
+static void ppp_print_buffer(const char *name, const char *buf, int count, int seg)
{
char line [44];
int old_fs = get_fs();
--- a/drivers/net/seeq8005.c
+++ b/drivers/net/seeq8005.c
*/
-static char *version =
+static const char *version =
"seeq8005.c:v1.00 8/07/95 Hamish Coleman (hamish@zot.apana.org.au)\n";
/* Always include 'config.h' first in case the user wants to turn on
diff --git a/drivers/net/sk_g16.cb/drivers/net/sk_g16.c
--- a/drivers/net/sk_g16.c
+++ b/drivers/net/sk_g16.c
*
-*/
-static char *rcsid = "$Id: sk_g16.c,v 1.1 1994/06/30 16:25:15 root Exp $";
+static const char *rcsid = "$Id: sk_g16.c,v 1.1 1994/06/30 16:25:15 root Exp $";
/*
* The Schneider & Koch (SK) G16 Network device driver is based
diff --git a/drivers/net/slhc.cb/drivers/net/slhc.c
--- a/drivers/net/slhc.c
+++ b/drivers/net/slhc.c
* Modularization.
* - Jan 1995 Bjorn Ekwall
* Use ip_fast_csum from ip.h
+ * - July 1995 Christos A. Polyzols
+ * Spotted bug in tcp option checking
*
*
* This module is a difficult issue. It's clearly inet code but it's also clearly
|| ip->ttl != cs->cs_ip.ttl
|| th->doff != cs->cs_tcp.doff
|| (ip->ihl > 5 && memcmp(ip+1,cs->cs_ipopt,((ip->ihl)-5)*4) != 0)
- || (th->doff > 5 && memcmp(th+1,cs->cs_tcpopt,((th->doff)-5)*4 != 0))){
+ || (th->doff > 5 && memcmp(th+1,cs->cs_tcpopt,((th->doff)-5)*4) != 0)){
goto uncompressed;
}
diff --git a/drivers/net/slip.cb/drivers/net/slip.c
--- a/drivers/net/slip.c
+++ b/drivers/net/slip.c
* and sent on to some IP layer for further processing.
*/
static void
-slip_receive_buf(struct tty_struct *tty, unsigned char *cp, char *fp, int count)
+slip_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
{
struct slip *sl = (struct slip *) tty->disc_data;
--- a/drivers/net/smc-ultra.c
+++ b/drivers/net/smc-ultra.c
use the non-8390-compatible "Altego" mode. (No support currently planned.)
*/
-static char *version =
+static const char *version =
"smc-ultra.c:v1.12 1/18/95 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
#include <linux/kernel.h>
{
int i;
int checksum = 0;
- char *model_name;
+ const char *model_name;
unsigned char eeprom_irq = 0;
/* Values from various config regs. */
unsigned char num_pages, irqreg, addr;
--- a/drivers/net/wavelan.c
+++ b/drivers/net/wavelan.c
extern int wavelan_probe(device *); /* See Space.c */
-static char *version = "wavelan.c:v7 95/4/8\n";
+static const char *version = "wavelan.c:v7 95/4/8\n";
/*
* Entry point forward declarations.
*/
static
int
-wavelan_synchronous_cmd(device *dev, char *str)
+wavelan_synchronous_cmd(device *dev, const char *str)
{
unsigned short ioaddr;
net_local *lp;
#if STRUCT_CHECK == 1
static
-char *
+const char *
wavelan_struct_check(void)
{
#define SC(t,s,n) if (sizeof(t) != s) return n
{
printk("dev:");
printk(" start=%d,", dev->start);
- printk(" tbusy=%d,", dev->tbusy);
+ printk(" tbusy=%ld,", dev->tbusy);
printk(" interrupt=%d,", dev->interrupt);
printk(" trans_start=%ld,", dev->trans_start);
printk(" flags=0x%x,", dev->flags);
diff --git a/drivers/net/wd.cb/drivers/net/wd.c
--- a/drivers/net/wd.c
+++ b/drivers/net/wd.c
Thanks to Russ Nelson (nelson@crnwyr.com) for loaning me a WD8013.
*/
-static char *version =
+static const char *version =
"wd.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
#include <linux/kernel.h>
int checksum = 0;
int ancient = 0; /* An old card without config registers. */
int word16 = 0; /* 0 = 8 bit, 1 = 16 bit */
- char *model_name;
+ const char *model_name;
for (i = 0; i < 8; i++)
checksum += inb(ioaddr + 8 + i);
diff --git a/drivers/net/znet.cb/drivers/net/znet.c
--- a/drivers/net/znet.c
+++ b/drivers/net/znet.c
/* znet.c: An Zenith Z-Note ethernet driver for linux. */
-static char *version = "znet.c:v1.02 9/23/94 becker@cesdis.gsfc.nasa.gov\n";
+static const char *version = "znet.c:v1.02 9/23/94 becker@cesdis.gsfc.nasa.gov\n";
/*
Written by Donald Becker.
diff --git a/drivers/pci/pci.cb/drivers/pci/pci.c
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
DEVICE( QLOGIC, QLOGIC_ISP1020, "ISP1020"),
DEVICE( QLOGIC, QLOGIC_ISP1022, "ISP1022"),
DEVICE( X, X_AGX016, "ITT AGX016"),
- DEVICE( VORTEX, VORTEX_GDT, "GDT 6000b")
+ DEVICE( VORTEX, VORTEX_GDT, "GDT 6000b"),
+ DEVICE( HP, HP_J2585A, "J2585A")
};
* optimizations...
*/
struct optimization_type {
- char *type;
- char *off;
- char *on;
+ const char *type;
+ const char *off;
+ const char *on;
} bridge_optimization[] = {
{"Cache L2", "write trough", "write back"},
{"CPU-PCI posted write", "off", "on"},
}
-char *pci_strbioserr (int error)
+const char *pci_strbioserr (int error)
{
switch (error) {
case PCIBIOS_SUCCESSFUL: return "SUCCESSFUL";
case PCI_VENDOR_ID_X: return "X TECHNOLOGY";
case PCI_VENDOR_ID_ACC: return "ACC MICROELECTRONICS";
case PCI_VENDOR_ID_VORTEX: return "VORTEX";
+ case PCI_VENDOR_ID_HP: return "Hewlett Packard";
default: return "Unknown vendor";
}
}
--- a/drivers/scsi/53c7,8xx.c
+++ b/drivers/scsi/53c7,8xx.c
static void intr_dma (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd);
static void print_dsa (struct Scsi_Host *host, u32 *dsa);
static int print_insn (struct Scsi_Host *host, u32 *insn,
- char *prefix, int kernel);
+ const char *prefix, int kernel);
static void NCR53c8xx_dsa_fixup (struct NCR53c7x0_cmd *cmd);
static void NCR53c8x0_init_fixup (struct Scsi_Host *host);
unsigned char dcmd, sbcl;
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata;
- char *phase;
+ const char *phase;
NCR53c7x0_local_setup(host);
if (!cmd) {
*/
static int print_insn (struct Scsi_Host *host, u32 *insn,
- char *prefix, int kernel) {
+ const char *prefix, int kernel) {
char buf[80], /* Temporary buffer and pointer */
*tmp;
unsigned char dcmd; /* dcmd register for *insn */
--- a/drivers/scsi/NCR5380.c
+++ b/drivers/scsi/NCR5380.c
#ifdef NDEBUG
static struct {
unsigned char mask;
- char * name;}
+ const char * name;}
signals[] = {{ SR_DBP, "PARITY"}, { SR_RST, "RST" }, { SR_BSY, "BSY" },
{ SR_REQ, "REQ" }, { SR_MSG, "MSG" }, { SR_CD, "CD" }, { SR_IO, "IO" },
{ SR_SEL, "SEL" }, {0, NULL}},
static struct {
unsigned char value;
- char *name;
+ const char *name;
} phases[] = {
{PHASE_DATAOUT, "DATAOUT"}, {PHASE_DATAIN, "DATAIN"}, {PHASE_CMDOUT, "CMDOUT"},
{PHASE_STATIN, "STATIN"}, {PHASE_MSGOUT, "MSGOUT"}, {PHASE_MSGIN, "MSGIN"},
--- a/drivers/scsi/aha152x.c
+++ b/drivers/scsi/aha152x.c
void aha152x_setup( char *str, int *ints );
static void aha152x_reset_ports(void);
-static void aha152x_panic(char *msg);
+static void aha152x_panic(const char *msg);
static void disp_ports(void);
static void show_command(Scsi_Cmnd *ptr);
/*
* Dump the current driver status and panic...
*/
-static void aha152x_panic(char *msg)
+static void aha152x_panic(const char *msg)
{
printk("\naha152x_panic: %s\n", msg);
show_queues();
--- a/drivers/scsi/aha1542.c
+++ b/drivers/scsi/aha1542.c
aha1542_intr_reset(bse);
}
-static int aha1542_getconfig(int base_io, unsigned char * irq_level, unsigned char * dma_chan)
+static int aha1542_getconfig(int base_io, unsigned char * irq_level, unsigned char * dma_chan, unsigned char * scsi_id)
{
unchar inquiry_cmd[] = {CMD_RETCONF };
unchar inquiry_result[3];
printk("Unable to determine Adaptec IRQ level. Disabling board\n");
return -1;
};
+ *scsi_id=inquiry_result[2] & 7;
return 0;
}
/* called from init/main.c */
void aha1542_setup( char *str, int *ints)
{
- char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n";
+ const char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n";
static int setup_idx = 0;
int setup_portbase;
{
unsigned char dma_chan;
unsigned char irq_level;
+ unsigned char scsi_id;
unsigned long flags;
unsigned int base_io;
int trans;
}
if(aha1542_query(base_io, &trans)) goto unregister;
- if (aha1542_getconfig(base_io, &irq_level, &dma_chan) == -1) goto unregister;
+ if (aha1542_getconfig(base_io, &irq_level, &dma_chan, &scsi_id) == -1) goto unregister;
- printk("Configuring Adaptec at IO:%x, IRQ %d",base_io, irq_level);
+ printk("Configuring Adaptec (SCSI-ID %d) at IO:%x, IRQ %d", scsi_id, base_io, irq_level);
if (dma_chan != 0xFF)
printk(", DMA priority %d", dma_chan);
printk("\n");
--- a/drivers/scsi/aic7xxx.c
+++ b/drivers/scsi/aic7xxx.c
*
* -- Daniel M. Eischen, deischen@iworks.InterWorks.org, 04/03/95
*
- * $Id: aic7xxx.c,v 1.49 1995/06/28 05:41:09 deang Exp $
+ * $Id: aic7xxx.c,v 2.0 1995/08/02 05:28:42 deang Exp $
*-M*************************************************************************/
#ifdef MODULE
#include <stdarg.h>
#include <asm/io.h>
#include <linux/string.h>
+#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/ioport.h>
#include <linux/bios32.h>
#include "hosts.h"
#include "aic7xxx.h"
-#define AIC7XXX_C_VERSION "$Revision: 1.49 $"
+#define AIC7XXX_C_VERSION "$Revision: 2.0 $"
#define NUMBER(arr) (sizeof(arr) / sizeof(arr[0]))
-#define MIN(a,b) ((a < b) ? a : b)
+#define MIN(a,b) ((a < b) ? a : b)
+#ifndef TRUE
+# define TRUE 1
+#endif
+#ifndef FALSE
+# define FALSE 0
+#endif
/*
* Defines for PCI bus support, testing twin bus support, DMAing of
/*
* Board Control (p. 3-43)
*/
-#define BCTL(x) ((x) + 0xC84ul)
+#define BCTL(x) ((x) + 0xC84ul)
/* RSVD 0xF0 */
#define ACE 0x08 /* Support for external processors */
/* RSVD 0x06 */
#define ENABLE 0x01
-#define BUSSPD(x) ((x) + 0xC86ul) /* FIFO threshold bits ? */
+/*
+ * Bus On/Off Time (p. 3-44)
+ */
+#define BUSTIME(x) ((x) + 0xC85ul)
+#define BOFF 0xF0
+#define BON 0x0F
+
+/*
+ * Bus Speed (p. 3-45)
+ */
+#define BUSSPD(x) ((x) + 0xC86ul)
+#define DFTHRSH 0xC0
+#define STBOFF 0x38
+#define STBON 0x07
/*
* Host Control (p. 3-47) R/W
* to zero inside the kernel - we have to initialize them all
* explicitly.
*
- * We support a maximum of one adapter card per IRQ level (see the
- * rationale for this above). On an interrupt, use the IRQ as an
- * index into aic7xxx_boards[] to locate the card information.
+ * We support multiple adapter cards per interrupt, but keep a
+ * linked list of Scsi_Host structures for each IRQ. On an interrupt,
+ * use the IRQ as an index into aic7xxx_boards[] to locate the card
+ * information.
*/
static struct Scsi_Host *aic7xxx_boards[MAXIRQ + 1];
/*
+ * When we detect and register the card, it is possible to
+ * have the card raise a spurious interrupt. Because we need
+ * to support multiple cards, we cannot tell which card caused
+ * the spurious interrupt. And, we might not even have added
+ * the card info to the linked list at the time the spurious
+ * interrupt gets raised. This variable is suppose to keep track
+ * of when we are registering a card and how many spurious
+ * interrupts we have encountered.
+ *
+ * 0 - do not allow spurious interrupts.
+ * 1 - allow 1 spurious interrupt
+ * 2 - have 1 spurious interrupt, do not allow any more.
+ *
+ * I've made it an integer instead of a boolean in case we
+ * want to allow more than one spurious interrupt for debugging
+ * purposes. Otherwise, it could just go from true to false to
+ * true (or something like that).
+ *
+ * When the driver detects the cards, we'll set the count to 1
+ * for each card detection and registration. After the registration
+ * of a card completes, we'll set the count back to 0. So far, it
+ * seems to be enough to allow a spurious interrupt only during
+ * card registration; if a spurious interrupt is going to occur,
+ * this is where it happens.
+ *
+ * We should be able to find a way to avoid getting the spurious
+ * interrupt. But until we do, we have to keep this ugly code.
+ */
+static int aic7xxx_spurious_count;
+
+/*
* The driver keeps up to four scb structures per card in memory. Only the
* first 26 bytes of the structure are valid for the hardware, the rest used
* for driver level bookeeping. The driver is further optimized
static struct {
unsigned char errno;
- char *errmesg;
+ const char *errmesg;
} hard_error[] = {
{ ILLHADDR, "Illegal Host Access" },
{ ILLSADDR, "Illegal Sequencer Address referrenced" },
static struct {
short period;
short rate;
- char *english;
+ const char *english;
} aic7xxx_syncrates[] = {
{ 100, 0, "10.0" },
{ 125, 1, "8.0" },
static int DFT[] = { 0, 50, 75, 100 };
static int SST[] = { 256, 128, 64, 32 };
- static char *BUSW[] = { "", "-TWIN", "-WIDE" };
+ static const char *BUSW[] = { "", "-TWIN", "-WIDE" };
host_conf = inb(HA_HOSTCONF(p->base));
scsi_conf = inb(HA_SCSICONF(p->base));
*/
if ((p->type == AIC_274x) || (p->type == AIC_284x))
{
- brelease = scsi_conf & 0x3F;
dfthresh = host_conf >> 6;
}
else
{
- brelease = p->busrtime;
dfthresh = scsi_conf >> 6;
}
+
+ brelease = p->busrtime;
if (brelease == 0)
{
brelease = 2;
char *p;
static struct {
- char *name;
+ const char *name;
int *flag;
} options[] = {
{ "extended", &aic7xxx_extended },
{
unsigned long i;
- i = jiffies + (seconds * 100); /* compute time to stop */
+ i = jiffies + (seconds * HZ); /* compute time to stop */
while (jiffies < i)
{
length = cmd->request_bufflen;
}
- return(length);
+ return (length);
}
/*+F*************************************************************************
unsigned char active, ha_flags, transfer;
unsigned char scsi_id, bus_width;
unsigned char offset, rate, scratch;
- unsigned char max_offset;
+ unsigned char max_offset, rej_byte;
unsigned char head, tail;
unsigned short target_mask;
long flags;
int target, tcl;
int scbptr;
Scsi_Cmnd *cmd;
-#if 0
-static int_count = 0;
-#endif
p = (struct aic7xxx_host *) aic7xxx_boards[irq]->hostdata;
-#ifdef AIC7XXX_SHARE_IRQS
+
/*
- * Search for the host with a pending interrupt.
+ * Search for the host with a pending interrupt. If we can't find
+ * one, then we've encountered a spurious interrupt.
*/
while ((p != NULL) && !(inb(INTSTAT(p->base)) & INT_PEND))
{
- p = (struct aic7xxx_host *) p->next->hostdata;
+ if (p->next == NULL)
+ {
+ p = NULL;
+ }
+ else
+ {
+ p = (struct aic7xxx_host *) p->next->hostdata;
+ }
}
+
if (p == NULL)
{
- printk("aic7xxx_isr: Encountered spurious interrupt.\n");
- return;
- }
-#endif
- base = p->base;
- if (p->isr_count == 0xffffffff)
- {
- p->isr_count = 0;
- }
- else
- {
- p->isr_count = p->isr_count + 1;
+ if (aic7xxx_spurious_count == 1)
+ {
+ aic7xxx_spurious_count = 2;
+ printk("aic7xxx_isr: Encountered spurious interrupt.\n");
+ return;
+ }
+ else
+ {
+ /*
+ * The best we can do is to set p back to head of list and process
+ * the erroneous interrupt - most likely a BRKADRINT.
+ */
+ p = (struct aic7xxx_host *) aic7xxx_boards[irq]->hostdata;
+ }
}
+
+ p->isr_count++; /* Keep track of interrupts for /proc/scsi */
+
if ((p->a_scanned == 0) && (p->isr_count == 1))
{
- /* Allow for one interrupt when the card is enabled. */
+ /*
+ * We must only have one card at this IRQ and it must have been
+ * added to the board data before the spurious interrupt occurred.
+ * It is sufficient that we check isr_count and not the spurious
+ * interrupt count.
+ */
+ printk("aic7xxx_isr: Encountered spurious interrupt.\n");
return;
}
+ base = p->base;
/*
* Handle all the interrupt sources - especially for SCSI
* interrupts, we won't get a second chance at them.
{
case BAD_PHASE:
panic("aic7xxx_isr: unknown scsi bus phase\n");
+ break;
case SEND_REJECT:
- debug("aic7xxx_isr warning: issuing message reject, 1st byte 0x%x\n",
- inb(HA_REJBYTE(base)));
+ rej_byte = inb(HA_REJBYTE(base));
+ scsi_id = inb(SCSIID(base)) >> 0x04;
+ scbptr = inb(SCBPTR(base));
+ scb = &(p->scb_array[scbptr]);
+ if (rej_byte != 0x20)
+ {
+ debug("aic7xxx_isr warning: issuing message reject, 1st byte 0x%x\n",
+ rej_byte);
+ }
+ else
+ {
+ printk("aic7xxx_isr warning: Tagged message rejected for target %d,"
+ " channel %c.\n",
+ scsi_id, (inb(SBLKCTL(base)) & SELBUSB ? 'B': 'A'));
+ scb->cmd->device->tagged_supported = 0;
+ scb->cmd->device->tagged_queue = 0;
+ }
break;
case NO_IDENT:
/*
* Send our own SDTR in reply.
*/
- printk("Sending SDTR!!\n");
+ printk("aic7xxx_isr: Sending SDTR!!\n");
outb(SEND_SDTR, HA_RETURN_1(base));
}
}
{
scsi_id = scsi_id + 8; /* B channel */
}
- printk("Received MSG_WDTR, scsi_id = %d, "
+ printk("aic7xxx_isr: Received MSG_WDTR, scsi_id = %d, "
"needwdtr = 0x%x\n", scsi_id, p->needwdtr);
scratch = inb(HA_TARG_SCRATCH(base) + scsi_id);
/*
* Send our own WDTR in reply.
*/
- printk("Will send WDTR!!\n");
+ printk("aic7xxx_isr: Will send WDTR!!\n");
switch (bus_width)
{
case BUS_8_BIT:
sizeof(scb->SCSI_cmd_pointer));
#ifdef AIC7XXX_USE_SG
scb->SG_segment_count = 1;
- memcpy (scb->SG_list_pointer, &req_buf,
+ memcpy(scb->SG_list_pointer, &req_buf,
sizeof(scb->SG_list_pointer));
#else
scb->SG_segment_count = 0;
- memcpy (scb->data_pointer, &req_buf,
+ memcpy(scb->data_pointer, &req_buf,
sizeof(scb->data_pointer));
- memcpy (scb->data_count, &req_buflen, 3);
+ memcpy(scb->data_count, &req_buflen, 3);
#endif
outb(SCBAUTO, SCBCNT(base));
scb->next = p->free_scb; /* preserve next pointer */
p->free_scb = scb; /* add at head of list */
- restore_flags (flags);
+ restore_flags(flags);
cmd->result = (DID_RETRY_COMMAND << 16);
cmd->scsi_done(cmd);
}
}
else
{
- panic ("aic7xxx_isr: AWAITING_SCB for an SCB that does "
- "not have a waiting message");
+ panic("aic7xxx_isr: AWAITING_SCB for an SCB that does "
+ "not have a waiting message");
}
}
break;
}
else
{
- if (! (status & BUSFREE))
+ if (!(status & BUSFREE))
{
/*
* We don't know what's going on. Turn off the
{
if (inb(base + 4) & 1)
{
- return(AIC7xxx[i].type);
+ return (AIC7xxx[i].type);
}
printk("aic7xxx disabled at slot %d, ignored\n", slot);
}
}
- return(AIC_NONE);
+ return (AIC_NONE);
}
/*+F*************************************************************************
}
if ((inb(SEECTL(base)) & SEERDY) == 0)
{
- outb (0, SEECTL(base));
+ outb(0, SEECTL(base));
return (0);
}
* but only the first 32 are used by Adaptec BIOS. The loop
* will range from 0 to 31.
*/
- for (k = 0; k < (sizeof(*sc) / 2); k = k + 1)
+ for (k = 0; k < (sizeof(*sc) / 2); k++)
{
/* Send chip select for one clock cycle. */
outb(SEEMS | SEECK | SEECS, SEECTL(base));
* Now we're ready to send the read command followed by the
* address of the 16-bit register we want to read.
*/
- for (i = 0; i < seeprom_read.len; i = i + 1)
+ for (i = 0; i < seeprom_read.len; i++)
{
temp = SEEMS | SEECS | (seeprom_read.bits[i] << 1);
outb(temp, SEECTL(base));
CLOCK_PULSE(base);
}
/* Send the 6 bit address (MSB first, LSB last). */
- for (i = 5; i >= 0; i = i - 1)
+ for (i = 5; i >= 0; i--)
{
temp = k;
temp = (temp >> i) & 1; /* Mask out all but lower bit. */
* with bit 0 (LSB). The initial 0 will be shifted off the
* top of our word as we let the loop run from 0 to 16.
*/
- for (i = 0; i <= 16; i = i + 1)
+ for (i = 0; i <= 16; i++)
{
temp = SEEMS | SEECS;
outb(temp, SEECTL(base));
if (checksum != sc->checksum)
{
- printk ("aic7xxx : SEEPROM checksum error, ignoring SEEPROM settings.\n");
+ printk("aic7xxx: SEEPROM checksum error, ignoring SEEPROM settings.\n");
return (0);
}
#if 0
- printk ("Computed checksum 0x%x, checksum read 0x%x\n", checksum, sc->checksum);
- printk ("Serial EEPROM:");
- for (k = 0; k < (sizeof(*sc) / 2); k = k + 1)
+ printk("Computed checksum 0x%x, checksum read 0x%x\n", checksum, sc->checksum);
+ printk("Serial EEPROM:");
+ for (k = 0; k < (sizeof(*sc) / 2); k++)
{
if (((k % 8) == 0) && (k != 0))
{
- printk ("\n ");
+ printk("\n ");
}
- printk (" 0x%x", seeprom[k]);
+ printk(" 0x%x", seeprom[k]);
}
- printk ("\n");
+ printk("\n");
#endif
/* Release access to the memory port and the serial EEPROM. */
break;
}
- return(maxscb);
+ return (maxscb);
}
/*+F*************************************************************************
aic7xxx_register(Scsi_Host_Template *template, aha_type type,
int base, unsigned char irq)
{
- static char * board_name[] = {"", "274x", "284x", "7870", "7850", "7872"};
+ static const char * board_name[] = {"", "274x", "284x", "7870", "7850", "7872"};
int i;
unsigned char sblkctl;
int max_targets;
int found = 1;
unsigned char target_settings;
- unsigned char scsi_conf;
+ unsigned char scsi_conf, host_conf;
int have_seeprom = 0;
struct Scsi_Host *host;
struct aic7xxx_host *p;
switch (type)
{
case AIC_274x:
-#if 1
+#if 0
printk("aha274x: aic7770 hcntrl=0x%x\n", inb(HCNTRL(config.base)));
#endif
/*
* since there was some issue about reseting the board.
*/
config.irq = inb(HA_INTDEF(config.base)) & 0x0F;
- config.busrtime = inb(HA_SCSICONF(config.base)) & 0x3C;
+ host_conf = inb(HA_HOSTCONF(config.base));
+ config.busrtime = host_conf & 0x3C;
+ /* XXX Is this valid for motherboard based controllers? */
+ /* Setup the FIFO threshold and the bus off time */
+ outb(host_conf & DFTHRSH, BUSSPD(config.base));
+ outb((host_conf << 2) & BOFF, BUSTIME(config.base));
/*
* A reminder until this can be detected automatically.
break;
case AIC_284x:
-#if 1
+#if 0
printk("aha284x: aic7770 hcntrl=0x%x\n", inb(HCNTRL(config.base)));
#endif
outb(CHIPRST, HCNTRL(config.base));
config.pause = REQ_PAUSE; /* DWG would like to be like the rest */
config.extended = aic7xxx_extended;
config.irq = inb(HA_INTDEF(config.base)) & 0x0F;
+ host_conf = inb(HA_HOSTCONF(config.base));
+ config.busrtime = host_conf & 0x3C;
+ /* XXX Is this valid for motherboard based controllers? */
+ /* Setup the FIFO threshold and the bus off time */
+ outb(host_conf & DFTHRSH, BUSSPD(config.base));
+ outb((host_conf << 2) & BOFF, BUSTIME(config.base));
/*
* A reminder until this can be detected automatically.
case AIC_7850:
case AIC_7870:
case AIC_7872:
-#if 1
+#if 0
printk("aic%s hcntrl=0x%x\n", board_name[type], inb(HCNTRL(config.base)));
#endif
config.extended = aic7xxx_extended;
config.scsi_id = 7;
- printk ("aic78xx: Reading SEEPROM... ");
+ printk("aic78xx: Reading SEEPROM... ");
have_seeprom = read_seeprom(base, &sc);
- if (! have_seeprom)
+ if (!have_seeprom)
{
- printk ("Unable to read SEEPROM\n");
+ printk("aic78xx: unable to read SEEPROM\n");
}
else
{
- printk ("done\n");
+ printk("done\n");
config.extended = (sc.bios_control & CFEXTEND) >> 7;
config.scsi_id = (sc.brtime_id & CFSCSIID);
config.parity = (sc.adapter_control & CFSPARITY) ?
case 2: /* Wide bus */
config.scsi_id = inb(HA_SCSICONF(base) + 1) & 0x0F;
config.bus_type = AIC_WIDE;
- printk("aic7xxx : Enabling wide channel of %s-Wide\n",
+ printk("aic7xxx: Enabling wide channel of %s-Wide\n",
board_name[config.type]);
outb(WIDE_BUS, HA_FLAGS(base));
break;
#ifdef AIC7XXX_TWIN_SUPPORT
config.scsi_id_b = inb(HA_SCSICONF(base) + 1) & 0x07;
config.bus_type = AIC_TWIN;
- printk("aic7xxx : Enabled channel B of %s-Twin\n",
+ printk("aic7xxx: Enabled channel B of %s-Twin\n",
board_name[config.type]);
outb(TWIN_BUS, HA_FLAGS(base));
#else
config.bus_type = AIC_SINGLE;
- printk("aic7xxx : Channel B of %s-Twin will be ignored\n",
+ printk("aic7xxx: Channel B of %s-Twin will be ignored\n",
board_name[config.type]);
outb(0, HA_FLAGS(base));
#endif
printk("aic7xxx is an unsupported type 0x%x, please "
"mail deang@ims.com\n", inb(SBLKCTL(base)));
outb(0, HA_FLAGS(base));
- return(0);
+ return (0);
}
/*
&& (config.irq < 9 || config.irq > 15))
{
printk("aic7xxx uses unsupported IRQ level, ignoring\n");
- return(0);
+ return (0);
}
/*
if (aic7xxx_boards[config.irq] != NULL)
{
printk("aic7xxx_register: Sharing of IRQs is not configured.\n");
- return(0);
+ return (0);
}
#endif
p = (struct aic7xxx_host *) host->hostdata;
/* Initialize the scb array by setting the state to free. */
- for (i = 0; i < AIC7XXX_MAXSCB; i = i + 1)
+ for (i = 0; i < AIC7XXX_MAXSCB; i++)
{
p->scb_array[i].state = SCB_FREE;
p->scb_array[i].next = NULL;
if (aic7xxx_boards[config.irq] == NULL)
{
/*
+ * Warning! This must be done before requesting the irq. It is
+ * possible for some boards to raise an interrupt as soon as
+ * they are enabled. So when we request the irq from the Linux
+ * kernel, an interrupt is triggered immediately. Therefore, we
+ * must ensure the board data is correctly set before the request.
+ */
+ aic7xxx_boards[config.irq] = host;
+
+ /*
* Register IRQ with the kernel.
*/
if (request_irq(config.irq, aic7xxx_isr, SA_INTERRUPT, "aic7xxx"))
{
printk("aic7xxx couldn't register irq %d, ignoring\n", config.irq);
- return(0);
+ aic7xxx_boards[config.irq] = NULL;
+ return (0);
}
- aic7xxx_boards[config.irq] = host;
}
else
{
max_targets = 16;
}
- for (i = 0; i < max_targets; i = i + 1)
+ for (i = 0; i < max_targets; i++)
{
if (have_seeprom)
{
p->needsdtr = p->needsdtr_copy;
p->needwdtr = p->needwdtr_copy;
+#if 0
printk("NeedSdtr = 0x%x, 0x%x\n", p->needsdtr_copy, p->needsdtr);
printk("NeedWdtr = 0x%x, 0x%x\n", p->needwdtr_copy, p->needwdtr);
+#endif 0
- /*
+ /*
* Clear the control byte for every SCB so that the sequencer
* doesn't get confused and think that one of them is valid
*/
- for (i = 0; i < config.maxscb; i = i + 1)
+ for (i = 0; i < config.maxscb; i++)
{
outb(i, SCBPTR(base));
outb(0, SCBARRAY(base));
if (!aic7xxx_no_reset)
{
printk("Resetting the SCSI bus...\n");
+ if (p->bus_type == AIC_TWIN)
+ {
+ /*
+ * Select channel B.
+ */
+ outb(2, SBLKCTL(base));
+ outb(SCSIRSTO, SCSISEQ(base));
+ udelay(1000);
+ outb(0, SCSISEQ(base));
+ /*
+ * Select channel A.
+ */
+ outb(0, SBLKCTL(base));
+ }
+
outb(SCSIRSTO, SCSISEQ(base));
udelay(1000);
outb(0, SCSISEQ(base));
* command is sent to us by the high-level SCSI code.
*/
UNPAUSE_SEQUENCER(p);
- return(found);
+ return (found);
}
/*+F*************************************************************************
}
/*
+ * Initialize the spurious count to 0.
+ */
+ aic7xxx_spurious_count = 0;
+
+ /*
* EISA/VL-bus card signature probe.
*/
for (slot = MINSLOT; slot <= MAXSLOT; slot++)
type = aic7xxx_probe(slot, HID0(base));
if (type != AIC_NONE)
{
- printk("aic7xxx: hcntrl=0x%x\n", inb(HCNTRL(base)));
+ /*
+ * We found a card, allow 1 spurious interrupt.
+ */
+ aic7xxx_spurious_count = 1;
+
#if 0
+ printk("aic7xxx: hcntrl=0x%x\n", inb(HCNTRL(base)));
outb(inb(HCNTRL(base)) | CHIPRST, HCNTRL(base));
irq = inb(HA_INTDEF(base)) & 0x0F;
#endif
* it with the kernel without incident.
*/
found += aic7xxx_register(template, type, base, irq);
+
+ /*
+ * Disallow spurious interrupts.
+ */
+ aic7xxx_spurious_count = 0;
}
}
#define DEVSTATUS 0x41
#define RAMPSM 0x02
-/* This should be defined in pci.h */
-#define PCI_DEVICE_ID_ADAPTEC_7850 0x5078
-#define PCI_DEVICE_ID_ADAPTEC_7872 0x7278
-
/*
* PCI-bus probe.
*/
*/
base = io_port - 0xC01;
+ /*
+ * I don't think we need to bother with allowing
+ * spurious interrupts for the 787x/7850, but what
+ * the hey.
+ */
+ aic7xxx_spurious_count = 1;
+
+#if 0
printk("aic7xxx: hcntrl=0x%x\n", inb(HCNTRL(base)));
+#endif
outb(inb(HCNTRL(base)) | CHIPRST, HCNTRL(base));
error = pcibios_read_config_byte(pci_bus, pci_device_fn,
DEVREVID, &devrevid);
if (devrevid < 3)
{
- printk ("aic7xxx_detect: AIC-7870 Rev %c\n", rev_id[devrevid]);
+ printk("aic7xxx_detect: AIC-7870 Rev %c\n", rev_id[devrevid]);
}
error = pcibios_read_config_byte(pci_bus, pci_device_fn,
DEVCONFIG, &devconfig);
error = pcibios_read_config_byte(pci_bus, pci_device_fn,
DEVSTATUS, &devstatus);
- printk ("aic7xxx_detect: devconfig 0x%x, devstatus 0x%x\n",
- devconfig, devstatus);
+ printk("aic7xxx_detect: devconfig 0x%x, devstatus 0x%x\n",
+ devconfig, devstatus);
if (devstatus & RAMPSM)
{
- printk ("aic7xxx_detect: detected external SCB RAM, "
- "mail deang@ims.com for test patch");
+ printk("aic7xxx_detect: detected external SCB RAM, "
+ "mail deang@ims.com for test patch");
}
found += aic7xxx_register(template, type, base, irq);
+
+ /*
+ * Disable spurious interrupts.
+ */
+ aic7xxx_spurious_count = 0;
+
index += 1;
}
}
}
#endif CONFIG_PCI
- template->name = (char *) aic7xxx_info(NULL);
- return(found);
+ template->name = aic7xxx_info(NULL);
+ return (found);
}
{
if (cmd->device->tagged_queue == 0)
{
- printk ("aic7xxx_buildscb: Enabling tagged queuing for target %d, "
- "channel %d\n", cmd->target, cmd->channel);
+ printk("aic7xxx_buildscb: Enabling tagged queuing for target %d, "
+ "channel %d\n", cmd->target, cmd->channel);
cmd->device->tagged_queue = 1;
cmd->device->current_tag = 1; /* enable tagging */
}
else
{
#if 0
- debug ("aic7xxx_buildscb: Creating scatterlist, addr=0x%lx, length=%d.\n",
- (unsigned long) cmd->request_buffer, cmd->request_bufflen);
+ debug("aic7xxx_buildscb: Creating scatterlist, addr=0x%lx, length=%d.\n",
+ (unsigned long) cmd->request_buffer, cmd->request_bufflen);
#endif
#ifdef AIC7XXX_USE_SG
scb->SG_segment_count = 1;
memset(scb, 0, sizeof(*scb));
scb->position = p->numscb;
- p->numscb = p->numscb + 1;
+ p->numscb++;
scb->state = SCB_ACTIVE;
scb->next_waiting = SCB_LIST_NULL;
memcpy(scb->host_scb, &scb, sizeof(scb));
aic7xxx_status(cmd) = 0;
cmd->result = 0;
- memset (&cmd->sense_buffer, 0, sizeof (cmd->sense_buffer));
+ memset(&cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
UNPAUSE_SEQUENCER(p);
restore_flags(flags);
- return(0);
+ return (0);
}
/* return values from aic7xxx_kill */
if (scbsave[i] == scb->position)
{
found = 1;
- i = i - 1;
+ i--;
}
}
p->free_scb = scb; /* add at head of free list */
cmd->result = cmd->result << 16;
cmd->scsi_done(cmd);
- return(status);
+ return (status);
}
/*+F*************************************************************************
}
restore_flags(flags);
- return(rv);
+ return (rv);
}
/*+F*************************************************************************
}
restore_flags(flags);
- return(SCSI_RESET_SUCCESS);
+ return (SCSI_RESET_SUCCESS);
}
/*+F*************************************************************************
geom[1] = sectors;
geom[2] = cylinders;
- return(0);
+ return (0);
}
#ifdef MODULE
#include "scsi_module.c"
#endif
+/*
+ * Overrides for Emacs so that we almost follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only. This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-indent-level: 2
+ * c-brace-imaginary-offset: 0
+ * c-brace-offset: -2
+ * c-argdecl-indent: 2
+ * c-label-offset: -2
+ * c-continued-statement-offset: 2
+ * c-continued-brace-offset: 0
+ * indent-tabs-mode: nil
+ * tab-width: 8
+ * End:
+ */
--- a/drivers/scsi/aic7xxx.h
+++ b/drivers/scsi/aic7xxx.h
* along with this program; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*
- * $Id: aic7xxx.h,v 1.18 1995/06/22 04:17:56 deang Exp $
+ * $Id: aic7xxx.h,v 2.0 1995/08/02 05:28:42 deang Exp $
*-M*************************************************************************/
#ifndef _aic7xxx_h
#define _aic7xxx_h
-#define AIC7XXX_H_VERSION "$Revision: 1.18 $"
+#define AIC7XXX_H_VERSION "$Revision: 2.0 $"
/*
* Scsi_Host_Template (see hosts.h) for AIC-7770/AIC-7870 - some fields
--- a/drivers/scsi/aic7xxx.seq
+++ b/drivers/scsi/aic7xxx.seq
#
# Copyright (c) 1994 John Aycock
# The University of Calgary Department of Computer Science.
-# All rights reserved.
#
# Modifications/enhancements:
# Copyright (c) 1994, 1995 Justin Gibbs. All rights reserved.
#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-# 1. Redistributions of source code must retain the above copyright
-# notice, this list of conditions, and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the above copyright
-# notice, this list of conditions and the following disclaimer in the
-# documentation and/or other materials provided with the distribution.
-# 3. All advertising materials mentioning features or use of this software
-# must display the following acknowledgement:
-# This product includes software developed by the University of Calgary
-# Department of Computer Science and its contributors.
-# 4. Neither the name of the University nor the names of its contributors
-# may be used to endorse or promote products derived from this software
-# without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-# SUCH DAMAGE.
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; see the file COPYING. If not, write to
+# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
#
# FreeBSD, Twin, Wide, 2 command per target support, tagged queuing and other
# optimizations provided by Justin T. Gibbs (gibbs@FreeBSD.org)
-#
##-M#########################################################################
-VERSION AIC7XXX_SEQ_VER "$Id: aic7xxx.seq,v 1.19 1995/06/05 06:11:41 deang Exp $"
+VERSION AIC7XXX_SEQ_VER "$Id: aic7xxx.seq,v 2.0 1995/08/02 05:28:42 deang Exp $"
SCBMASK = 0x1f
*
* A <label> is an <undef-sym> ending in a colon. Spaces, tabs, and commas
* are token separators.
- *
*-M*************************************************************************/
-static char id[] = "$Id: aic7xxx_asm.c,v 1.8 1995/05/25 06:25:36 root Exp $";
+static char id[] = "$Id: aic7xxx_asm.c,v 2.0 1995/08/02 05:28:42 deang Exp $";
#include <ctype.h>
#include <stdio.h>
#include <string.h>
unsigned char M[MEMORY][4];
void
-error(char *s)
+error(const char *s)
{
fprintf(stderr, "%s: %s at line %d\n", filename, s, lineno);
exit(EXIT_FAILURE);
#define NA -1 /* not applicable */
struct {
- char *name;
+ const char *name;
int n; /* number of operands, including opcode */
unsigned int op; /* immediate or L?|pos_from_0 */
unsigned int dest; /* NA, pos_from_0, or I|immediate */
static struct {
unsigned int what;
- char *name;
+ const char *name;
int value;
} jmptab[] = {
{ LO, "jmp", 8 },
--- a/drivers/scsi/constants.c
+++ b/drivers/scsi/constants.c
struct error_info{
unsigned char code1, code2;
unsigned short int devices;
- char * text;
+ const char * text;
};
struct error_info2{
unsigned char code1, code2_min, code2_max;
unsigned short int devices;
- char * text;
+ const char * text;
};
static struct error_info2 additional2[] =
#endif
#if (CONSTANTS & CONST_SENSE)
-static char *snstext[] = {
+static const char *snstext[] = {
"None","Recovered Error","Not Ready","Medium Error","Hardware Error",
"Illegal Request","Unit Attention","Data Protect","Blank Check",
"Key=9","Copy Aborted","Aborted Command","End-Of-Medium",
/* Print sense information */
-void print_sense(char * devclass, Scsi_Cmnd * SCpnt)
+void print_sense(const char * devclass, Scsi_Cmnd * SCpnt)
{
int i, s;
int sense_class, valid, code;
unsigned char * sense_buffer = SCpnt->sense_buffer;
- char * error = NULL;
+ const char * error = NULL;
int dev = SCpnt->request.dev;
sense_class = (sense_buffer[0] >> 4) & 0x07;
--- a/drivers/scsi/constants.h
+++ b/drivers/scsi/constants.h
#define _CONSTANTS_H
extern void print_command(unsigned char *);
extern int print_msg(unsigned char *);
-extern void print_sense(char *, Scsi_Cmnd *);
+/* extern void print_sense(const char *, Scsi_Cmnd *); */
extern void print_status(int);
extern void print_Scsi_Cmnd (Scsi_Cmnd *);
#endif /* def _CONSTANTS_H */
diff --git a/drivers/scsi/eata.cb/drivers/scsi/eata.c
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
};
static struct Scsi_Host * sh[MAX_BOARDS + 1];
-static char* driver_name = "EATA";
+static const char* driver_name = "EATA";
static unsigned int irqlist[MAX_IRQ], calls[MAX_IRQ];
#define HD(board) ((struct hostdata *) &sh[board]->hostdata)
unsigned char irq, dma_channel, subversion;
unsigned char protocol_rev;
struct eata_info info;
- char *board_status;
+ const char *board_status;
/* Allowed DMA channels for ISA (0 indicates reserved) */
unsigned char dma_channel_table[4] = { 5, 6, 7, 0 };
--- a/drivers/scsi/eata_pio.c
+++ b/drivers/scsi/eata_pio.c
static ulong int_counter = 0;
static ulong queue_counter = 0;
-void hprint(char *str)
+void hprint(const char *str)
{
char *hptr =(char *) 0x000b0000;
char *hptr2=(char *) 0x000b00a0;
--- a/drivers/scsi/fdomain.c
+++ b/drivers/scsi/fdomain.c
*/
struct signature {
- char *signature;
+ const char *signature;
int sig_offset;
int sig_length;
int major_bios_version;
diff --git a/drivers/scsi/hosts.hb/drivers/scsi/hosts.h
--- a/drivers/scsi/hosts.h
+++ b/drivers/scsi/hosts.h
int (*proc_info)(char *, char **, off_t, int, int, int);
/* driver name that will appear in the /proc/scsi directory */
- char *procname;
+ const char *procname;
/* low_ino of the drivers /proc/scsi entry. Defined in proc_fs.h */
unsigned short low_ino;
* The name pointer is a pointer to the name of the SCSI
* device detected.
*/
- char *name;
+ const char *name;
/*
* The detect function shall return non zero on detection,
struct Scsi_Device_Template
{
struct Scsi_Device_Template * next;
- char * name;
- char * tag;
+ const char * name;
+ const char * tag;
int * usage_count; /* Used for loadable modules */
unsigned char scsi_type;
unsigned char major;
diff --git a/drivers/scsi/scsi.cb/drivers/scsi/scsi.c
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
#define BLIST_SINGLELUN 0x10
struct dev_info{
- char * vendor;
- char * model;
- char * revision; /* Latest revision known to be bad. Not used yet */
+ const char * vendor;
+ const char * model;
+ const char * revision; /* Latest revision known to be bad. Not used yet */
unsigned flags;
};
* the completion function for the high level driver.
*/
- memcpy ((void *) SCpnt->data_cmnd , (void *) cmnd, 12);
+ memcpy ((void *) SCpnt->data_cmnd , (const void *) cmnd, 12);
#if 0
SCpnt->host = host;
SCpnt->channel = channel;
SCpnt->done = done;
SCpnt->timeout_per_command = timeout;
- memcpy ((void *) SCpnt->cmnd , (void *) cmnd, 12);
+ memcpy ((void *) SCpnt->cmnd , (const void *) cmnd, 12);
/* Zero the sense buffer. Some host adapters automatically request
* sense on error. 0 is not a valid sense code.
*/
diff --git a/drivers/scsi/scsi.hb/drivers/scsi/scsi.h
--- a/drivers/scsi/scsi.h
+++ b/drivers/scsi/scsi.h
extern int kernel_scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
extern int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
extern void print_command(unsigned char *);
-extern void print_sense(char *, Scsi_Cmnd *);
+extern void print_sense(const char *, Scsi_Cmnd *);
#if defined(MAJOR_NR) && (MAJOR_NR != SCSI_TAPE_MAJOR)
--- a/drivers/scsi/seagate.c
+++ b/drivers/scsi/seagate.c
in some command phase.
*/
-static void *base_address = NULL; /*
+static const void *base_address = NULL; /*
Where the card ROM starts,
used to calculate memory mapped
register location.
};
typedef struct {
- char *signature ;
+ const char *signature ;
unsigned offset;
unsigned length;
unsigned char type;
for (i = 0; i < (sizeof (seagate_bases) / sizeof (char * )); ++i)
for (j = 0; !base_address && j < NUM_SIGNATURES; ++j)
- if (!memcmp ((void *) (seagate_bases[i] +
- signatures[j].offset), (void *) signatures[j].signature,
+ if (!memcmp ((const void *) (seagate_bases[i] +
+ signatures[j].offset), (const void *) signatures[j].signature,
signatures[j].length)) {
- base_address = (void *) seagate_bases[i];
+ base_address = (const void *) seagate_bases[i];
controller_type = signatures[j].type;
}
#endif /* OVERRIDE */
if (base_address)
{
- st0x_cr_sr =(void *) (((unsigned char *) base_address) + (controller_type == SEAGATE ? 0x1a00 : 0x1c00));
- st0x_dr = (void *) (((unsigned char *) base_address ) + (controller_type == SEAGATE ? 0x1c00 : 0x1e00));
+ st0x_cr_sr =(void *) (((const unsigned char *) base_address) + (controller_type == SEAGATE ? 0x1a00 : 0x1c00));
+ st0x_dr = (void *) (((const unsigned char *) base_address ) + (controller_type == SEAGATE ? 0x1c00 : 0x1e00));
#ifdef DEBUG
printk("%s detected. Base address = %x, cr = %x, dr = %x\n", tpnt->name, base_address, st0x_cr_sr, st0x_dr);
#endif
while (((status_read = STATUS) & STAT_BSY) &&
((status_read & REQ_MASK) == REQ_CMDOUT))
if (status_read & STAT_REQ) {
- DATA = *(unsigned char *) cmnd;
- cmnd = 1+(unsigned char *) cmnd;
+ DATA = *(const unsigned char *) cmnd;
+ cmnd = 1+(const unsigned char *) cmnd;
#ifdef SLOW_HANDSHAKE
if (borken)
borken_wait();
diff --git a/drivers/scsi/sg.cb/drivers/scsi/sg.c
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
#define SG_SEND 0
#define SG_REC 1
-static int sg_write(struct inode *inode,struct file *filp,char *buf,int count)
+static int sg_write(struct inode *inode,struct file *filp,const char *buf,int count)
{
int bsize,size,amt,i;
unsigned char cmnd[MAX_COMMAND_SIZE];
int direction;
unsigned char opcode;
Scsi_Cmnd * SCpnt;
- int sgcnt;
if ((i=verify_area(VERIFY_READ,buf,count)))
return i;
diff --git a/drivers/scsi/sr.cb/drivers/scsi/sr.c
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
void cleanup_module( void)
{
- int i;
-
if (MOD_IN_USE) {
printk(KERN_INFO __FILE__ ": module is in use, remove rejected\n");
return;
diff --git a/drivers/scsi/st.cb/drivers/scsi/st.c
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
int dev = SCpnt->request.dev;
int result = SCpnt->result;
unsigned char * sense = SCpnt->sense_buffer, scode;
- char *stp;
+ const char *stp;
if (!result /* && SCpnt->sense_buffer[0] == 0 */ )
return 0;
\f
/* Write command */
static int
-st_write(struct inode * inode, struct file * filp, char * buf, int count)
+st_write(struct inode * inode, struct file * filp, const char * buf, int count)
{
int dev;
int total, do_count, blks, retval, transfer;
int write_threshold;
int doing_write = 0;
static unsigned char cmd[10];
- char *b_point;
+ const char *b_point;
Scsi_Cmnd * SCpnt;
Scsi_Tape * STp;
unsigned int flags;
--- a/drivers/scsi/u14-34f.c
+++ b/drivers/scsi/u14-34f.c
};
static struct Scsi_Host * sh[MAX_BOARDS + 1];
-static char* driver_name = "Ux4F";
+static const char* driver_name = "Ux4F";
static unsigned int irqlist[MAX_IRQ], calls[MAX_IRQ];
#define HD(board) ((struct hostdata *) &sh[board]->hostdata)
--- a/drivers/scsi/wd7000.c
+++ b/drivers/scsi/wd7000.c
* added for the Future Domain version.
*/
typedef struct signature {
- void *sig; /* String to look for */
- unsigned ofs; /* offset from BIOS base address */
- unsigned len; /* length of string */
+ const void *sig; /* String to look for */
+ unsigned ofs; /* offset from BIOS base address */
+ unsigned len; /* length of string */
} Signature;
static const Signature signatures[] = {
diff --git a/drivers/sound/pss.cb/drivers/sound/pss.c
--- a/drivers/sound/pss.c
+++ b/drivers/sound/pss.c
}
#ifdef EXCLUDE_MIDI
- return 0
+ return 0;
#else
return probe_mpu401 (hw_config);
#endif
diff --git a/fs/binfmt_elf.cb/fs/binfmt_elf.c
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
* These are the only things you should do on a core-file: use only these
* functions to write out all the necessary info.
*/
-static int dump_write(struct file *file, void *addr, int nr)
+static int dump_write(struct file *file, const void *addr, int nr)
{
return file->f_op->write(file->f_inode, file, addr, nr) == nr;
}
/* An ELF note in memory */
struct memelfnote
{
- char *name;
+ const char *name;
int type;
unsigned int datasz;
void *data;
diff --git a/fs/block_dev.cb/fs/block_dev.c
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
#define MAX_BUF_PER_PAGE (PAGE_SIZE / 512)
#define NBUF 64
-int block_write(struct inode * inode, struct file * filp, char * buf, int count)
+int block_write(struct inode * inode, struct file * filp, const char * buf, int count)
{
int blocksize, blocksize_bits, i, j, buffercount,write_error;
int block, blocks;
if (offset > size)
left = 0;
+ /* size - offset might not fit into left, so check explicitly. */
+ else if (size - offset > INT_MAX)
+ left = INT_MAX;
else
left = size - offset;
if (left > count)
diff --git a/fs/dcache.cb/fs/dcache.c
--- a/fs/dcache.c
+++ b/fs/dcache.c
*/
static inline unsigned long namehash(const char * name, int len)
{
- return len * *(unsigned char *) name;
+ return len * *(const unsigned char *) name;
}
/*
diff --git a/fs/ext/file.cb/fs/ext/file.c
--- a/fs/ext/file.c
+++ b/fs/ext/file.c
#include <linux/ext_fs.h>
static int ext_file_read(struct inode *, struct file *, char *, int);
-static int ext_file_write(struct inode *, struct file *, char *, int);
+static int ext_file_write(struct inode *, struct file *, const char *, int);
/*
* We have mostly NULL's here: the current defaults are ok for
return read;
}
-static int ext_file_write(struct inode * inode, struct file * filp, char * buf, int count)
+static int ext_file_write(struct inode * inode, struct file * filp, const char * buf, int count)
{
off_t pos;
int written,c;
diff --git a/fs/ext2/dir.cb/fs/ext2/dir.c
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
NULL /* smap */
};
-int ext2_check_dir_entry (char * function, struct inode * dir,
+int ext2_check_dir_entry (const char * function, struct inode * dir,
struct ext2_dir_entry * de, struct buffer_head * bh,
unsigned long offset)
{
- char * error_msg = NULL;
+ const char * error_msg = NULL;
if (de->rec_len < EXT2_DIR_REC_LEN(1))
error_msg = "rec_len is smaller than minimal";
diff --git a/fs/ext2/file.cb/fs/ext2/file.c
--- a/fs/ext2/file.c
+++ b/fs/ext2/file.c
#include <linux/ext2_fs.h>
static int ext2_file_read (struct inode *, struct file *, char *, int);
-static int ext2_file_write (struct inode *, struct file *, char *, int);
+static int ext2_file_write (struct inode *, struct file *, const char *, int);
static void ext2_release_file (struct inode *, struct file *);
/*
}
static int ext2_file_write (struct inode * inode, struct file * filp,
- char * buf, int count)
+ const char * buf, int count)
{
const loff_t two_gb = 2147483647;
loff_t pos;
diff --git a/fs/isofs/namei.cb/fs/isofs/namei.c
--- a/fs/isofs/namei.c
+++ b/fs/isofs/namei.c
*
* NOTE! unlike strncmp, isofs_match returns 1 for success, 0 for failure.
*/
-static int isofs_match(int len,const char * name, char * compare, int dlen)
+static int isofs_match(int len,const char * name, const char * compare, int dlen)
{
if (!compare)
return 0;
diff --git a/fs/minix/file.cb/fs/minix/file.c
--- a/fs/minix/file.c
+++ b/fs/minix/file.c
#include <linux/minix_fs.h>
static int minix_file_read(struct inode *, struct file *, char *, int);
-static int minix_file_write(struct inode *, struct file *, char *, int);
+static int minix_file_write(struct inode *, struct file *, const char *, int);
/*
* We have mostly NULL's here: the current defaults are ok for
return read;
}
-static int minix_file_write(struct inode * inode, struct file * filp, char * buf, int count)
+static int minix_file_write(struct inode * inode, struct file * filp, const char * buf, int count)
{
off_t pos;
int written,c;
diff --git a/fs/msdos/file.cb/fs/msdos/file.c
--- a/fs/msdos/file.c
+++ b/fs/msdos/file.c
int msdos_file_write(
struct inode *inode,
struct file *filp,
- char *buf,
+ const char *buf,
int count)
{
struct super_block *sb = inode->i_sb;
int sector,offset,size,left,written;
int error,carry;
- char *start,*to,ch;
+ const char *start;
+ char *to,ch;
struct buffer_head *bh;
int binary_mode = MSDOS_I(inode)->i_binary;
diff --git a/fs/msdos/misc.cb/fs/msdos/misc.c
--- a/fs/msdos/misc.c
+++ b/fs/msdos/misc.c
* read-only. The file system can be made writable again by remounting it.
*/
-void fs_panic(struct super_block *s,char *msg)
+void fs_panic(struct super_block *s,const char *msg)
{
int not_ro;
(*number)++; \
}
-static int raw_scan_sector(struct super_block *sb,int sector,char *name,
+static int raw_scan_sector(struct super_block *sb,int sector,const char *name,
int *number,int *ino,struct buffer_head **res_bh,
struct msdos_dir_entry **res_de)
{
* requested entry is found or the end of the directory is reached.
*/
-static int raw_scan_root(struct super_block *sb,char *name,int *number,int *ino,
+static int raw_scan_root(struct super_block *sb,const char *name,int *number,int *ino,
struct buffer_head **res_bh,struct msdos_dir_entry **res_de)
{
int count,cluster;
* requested entry is found or the end of the directory is reached.
*/
-static int raw_scan_nonroot(struct super_block *sb,int start,char *name,
+static int raw_scan_nonroot(struct super_block *sb,int start,const char *name,
int *number,int *ino,struct buffer_head **res_bh,struct msdos_dir_entry
**res_de)
{
* being created.
*/
-static int raw_scan(struct super_block *sb,int start,char *name,int *number,
+static int raw_scan(struct super_block *sb,int start,const char *name,int *number,
int *ino,struct buffer_head **res_bh,struct msdos_dir_entry **res_de)
{
if (start)
* for an empty directory slot (name is NULL). Returns an error code or zero.
*/
-int msdos_scan(struct inode *dir,char *name,struct buffer_head **res_bh,
+int msdos_scan(struct inode *dir,const char *name,struct buffer_head **res_bh,
struct msdos_dir_entry **res_de,int *ino)
{
int res;
diff --git a/fs/msdos/namei.cb/fs/msdos/namei.c
--- a/fs/msdos/namei.c
+++ b/fs/msdos/namei.c
/* MS-DOS "device special files" */
-static char *reserved_names[] = {
+static const char *reserved_names[] = {
"CON ","PRN ","NUL ","AUX ",
"LPT1 ","LPT2 ","LPT3 ","LPT4 ",
"COM1 ","COM2 ","COM3 ","COM4 ",
static int msdos_format_name(char conv,const char *name,int len,char *res,
int dot_dirs)
{
- char *walk,**reserved;
+ char *walk;
+ const char **reserved;
unsigned char c;
int space;
/* Creates a directory entry (name is already formatted). */
-static int msdos_create_entry(struct inode *dir,char *name,int is_dir,
+static int msdos_create_entry(struct inode *dir,const char *name,int is_dir,
struct inode **result)
{
struct super_block *sb = dir->i_sb;
diff --git a/fs/nfs/dir.cb/fs/nfs/dir.c
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
entry->fhandle = *fhandle;
entry->fattr = *fattr;
entry->expiration_date = jiffies + (S_ISDIR(fattr->mode)
- ? NFS_SERVER(dir)->acdirmax : NFS_SERVER(dir)->acregmax);
+ ? NFS_SERVER(dir)->acdirmin : NFS_SERVER(dir)->acregmin);
}
static void nfs_lookup_cache_remove(struct inode *dir, struct inode *inode,
diff --git a/fs/nfs/file.cb/fs/nfs/file.c
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
#include <linux/malloc.h>
static int nfs_file_read(struct inode *, struct file *, char *, int);
-static int nfs_file_write(struct inode *, struct file *, char *, int);
+static int nfs_file_write(struct inode *, struct file *, const char *, int);
static int nfs_fsync(struct inode *, struct file *);
static struct file_operations nfs_file_operations = {
return i + hunk;
}
-static int nfs_file_write(struct inode *inode, struct file *file, char *buf,
+static int nfs_file_write(struct inode *inode, struct file *file, const char *buf,
int count)
{
int result, hunk, i, n, pos;
diff --git a/fs/nfs/proc.cb/fs/nfs/proc.c
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
}
-static inline int *xdr_encode_data(int *p, char *data, int len)
+static inline int *xdr_encode_data(int *p, const char *data, int len)
{
int quadlen = QUADLEN(len);
}
int nfs_proc_write(struct nfs_server *server, struct nfs_fh *fhandle,
- int offset, int count, char *data, struct nfs_fattr *fattr)
+ int offset, int count, const char *data, struct nfs_fattr *fattr)
{
int *p, *p0;
int status;
diff --git a/fs/pipe.cb/fs/pipe.c
--- a/fs/pipe.c
+++ b/fs/pipe.c
return 0;
}
-static int pipe_write(struct inode * inode, struct file * filp, char * buf, int count)
+static int pipe_write(struct inode * inode, struct file * filp, const char * buf, int count)
{
int chars = 0, free = 0, written = 0;
char *pipebuf;
@@ -121,7+121,12 @@ static int pipe_lseek(struct inode * inode, struct file * file, off_t offset, in
return -ESPIPE;
}
-static int bad_pipe_rw(struct inode * inode, struct file * filp, char * buf, int count)
+static int bad_pipe_r(struct inode * inode, struct file * filp, char * buf, int count)
+{
+ return -EBADF;
+}
+
+static int bad_pipe_w(struct inode * inode, struct file * filp, const char * buf, int count)
{
return -EBADF;
}
struct file_operations connecting_fifo_fops = {
pipe_lseek,
connect_read,
- bad_pipe_rw,
+ bad_pipe_w,
NULL, /* no readdir */
connect_select,
pipe_ioctl,
struct file_operations read_fifo_fops = {
pipe_lseek,
pipe_read,
- bad_pipe_rw,
+ bad_pipe_w,
NULL, /* no readdir */
fifo_select,
pipe_ioctl,
struct file_operations write_fifo_fops = {
pipe_lseek,
- bad_pipe_rw,
+ bad_pipe_r,
pipe_write,
NULL, /* no readdir */
fifo_select,
struct file_operations read_pipe_fops = {
pipe_lseek,
pipe_read,
- bad_pipe_rw,
+ bad_pipe_w,
NULL, /* no readdir */
pipe_select,
pipe_ioctl,
struct file_operations write_pipe_fops = {
pipe_lseek,
- bad_pipe_rw,
+ bad_pipe_r,
pipe_write,
NULL, /* no readdir */
pipe_select,
diff --git a/fs/proc/array.cb/fs/proc/array.c
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
}
/* Writing to /proc/profile resets the counters */
-static int write_profile(struct inode * inode, struct file * file, char * buf, int count)
+static int write_profile(struct inode * inode, struct file * file, const char * buf, int count)
{
int i=prof_len;
diff --git a/fs/proc/inode.cb/fs/proc/inode.c
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
return;
}
ino &= 0x0000ffff;
- if (ino == PROC_PID_INO ||
- (p->dumpable && p->uid == p->euid && p->gid == p->egid)) {
- inode->i_uid = p->uid;
- inode->i_gid = p->gid;
+ if (ino == PROC_PID_INO || p->dumpable) {
+ inode->i_uid = p->euid;
+ inode->i_gid = p->egid;
}
switch (ino) {
case PROC_PID_INO:
diff --git a/fs/proc/scsi.cb/fs/proc/scsi.c
--- a/fs/proc/scsi.c
+++ b/fs/proc/scsi.c
static int proc_readscsi(struct inode * inode, struct file * file,
char * buf, int count);
static int proc_writescsi(struct inode * inode, struct file * file,
- char * buf, int count);
+ const char * buf, int count);
static int proc_readscsidir(struct inode *, struct file *,
void *, filldir_t filldir);
static int proc_lookupscsi(struct inode *,const char *,int,struct inode **);
static int proc_writescsi(struct inode * inode, struct file * file,
- char * buf, int count)
+ const char * buf, int count)
{
int ret = 0;
char * page;
diff --git a/fs/smbfs/file.cb/fs/smbfs/file.c
--- a/fs/smbfs/file.c
+++ b/fs/smbfs/file.c
}
static int
-smb_file_write(struct inode *inode, struct file *file, char *buf, int count)
+smb_file_write(struct inode *inode, struct file *file, const char *buf, int count)
{
int result, bufsize, to_write, already_written;
off_t pos;
diff --git a/fs/smbfs/proc.cb/fs/smbfs/proc.c
--- a/fs/smbfs/proc.c
+++ b/fs/smbfs/proc.c
int
smb_proc_write(struct smb_server *server, struct smb_dirent *finfo,
- off_t offset, int count, char *data)
+ off_t offset, int count, const char *data)
{
int res = 0;
char *buf = server->packet;
struct smb_prots {
enum smb_protocol prot;
- char *name;
+ const char *name;
};
/* smb_proc_reconnect: We expect the server to be locked, so that you
diff --git a/fs/super.cb/fs/super.c
--- a/fs/super.c
+++ b/fs/super.c
return len;
}
-struct file_system_type *get_fs_type(char *name)
+struct file_system_type *get_fs_type(const char *name)
{
struct file_system_type * fs = file_systems;
sb->s_op->put_super(sb);
}
-static struct super_block * read_super(dev_t dev,char *name,int flags,
+static struct super_block * read_super(dev_t dev,const char *name,int flags,
void *data, int silent)
{
struct super_block * s;
* We also have to flush all inode-data for this device, as the new mount
* might need new info.
*/
-static int do_mount(dev_t dev, const char * dir, char * type, int flags, void * data)
+static int do_mount(dev_t dev, const char * dir, const char * type, int flags, void * data)
{
struct inode * dir_i;
struct super_block * sb;
struct file_operations * fops;
dev_t dev;
int retval;
- char * t;
+ const char * t;
unsigned long flags = 0;
unsigned long page = 0;
diff --git a/fs/sysv/file.cb/fs/sysv/file.c
--- a/fs/sysv/file.c
+++ b/fs/sysv/file.c
#include <linux/fs.h>
#include <linux/sysv_fs.h>
-static int sysv_file_write(struct inode *, struct file *, char *, int);
+static int sysv_file_write(struct inode *, struct file *, const char *, int);
/*
* We have mostly NULL's here: the current defaults are ok for
return read;
}
-static int sysv_file_write(struct inode * inode, struct file * filp, char * buf, int count)
+static int sysv_file_write(struct inode * inode, struct file * filp, const char * buf, int count)
{
struct super_block * sb = inode->i_sb;
off_t pos;
diff --git a/fs/umsdos/emd.cb/fs/umsdos/emd.c
--- a/fs/umsdos/emd.c
+++ b/fs/umsdos/emd.c
int umsdos_file_write_kmem(
struct inode *inode,
struct file *filp,
- char *buf,
+ const char *buf,
int count)
{
int ret;
diff --git a/fs/umsdos/file.cb/fs/umsdos/file.c
--- a/fs/umsdos/file.c
+++ b/fs/umsdos/file.c
static int UMSDOS_file_write(
struct inode *inode,
struct file *filp,
- char *buf,
+ const char *buf,
int count)
{
return msdos_file_write(inode,filp,buf,count);
diff --git a/fs/umsdos/mangle.cb/fs/umsdos/mangle.c
--- a/fs/umsdos/mangle.c
+++ b/fs/umsdos/mangle.c
like this.
*/
int i;
- static char *spc = "\"*+,/:;<=>?[\\]|~";
+ static const char *spc = "\"*+,/:;<=>?[\\]|~";
is_init = 1;
for (i=0; i<=32; i++) lkp[i] = '#';
for (i=33; i<'A'; i++) lkp[i] = (char)i;
diff --git a/fs/umsdos/namei.cb/fs/umsdos/namei.c
--- a/fs/umsdos/namei.c
+++ b/fs/umsdos/namei.c
struct file filp;
filp.f_pos = 0;
/* Make the inode acceptable to MSDOS */
- ret = umsdos_file_write_kmem (inode,&filp,(char*)symname,len);
+ ret = umsdos_file_write_kmem (inode,&filp,symname,len);
iput (inode);
if (ret >= 0){
if (ret != len){
diff --git a/fs/xiafs/file.cb/fs/xiafs/file.c
--- a/fs/xiafs/file.c
+++ b/fs/xiafs/file.c
#define MAX(a,b) (((a)>(b))?(a):(b))
static int xiafs_file_read(struct inode *, struct file *, char *, int);
-static int xiafs_file_write(struct inode *, struct file *, char *, int);
+static int xiafs_file_write(struct inode *, struct file *, const char *, int);
/*
* We have mostly NULL's here: the current defaults are ok for
}
static int
-xiafs_file_write(struct inode * inode, struct file * filp, char * buf, int count)
+xiafs_file_write(struct inode * inode, struct file * filp, const char * buf, int count)
{
off_t pos;
int written, c;
*
* it's best to have buff aligned on a 32-bit boundary
*/
-extern unsigned int csum_partial(unsigned char * buff, int len, unsigned int sum);
+extern unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum);
/*
* the same as csum_partial, but copies from src while it
* here even more important to align src and dst on a 32-bit (or even
* better 64-bit) boundary
*/
-unsigned int csum_partial_copy( char *src, char *dst, int len, int sum);
+unsigned int csum_partial_copy( const char *src, char *dst, int len, int sum);
/*
* the same as csum_partial, but copies from user space (but on the alpha
--- a/include/asm-alpha/dma.h
+++ b/include/asm-alpha/dma.h
/* These are in kernel/dma.c: */
-extern int request_dma(unsigned int dmanr, char * device_id); /* reserve a DMA channel */
+extern int request_dma(unsigned int dmanr, const char * device_id); /* reserve a DMA channel */
extern void free_dma(unsigned int dmanr); /* release it again */
*
* it's best to have buff aligned on a 32-bit boundary
*/
-unsigned int csum_partial(unsigned char * buff, int len, unsigned int sum);
+unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum);
/*
* the same as csum_partial, but copies from src while it
* better 64-bit) boundary
*/
-unsigned int csum_partial_copy( char *src, char *dst, int len, int sum);
+unsigned int csum_partial_copy( const char *src, char *dst, int len, int sum);
/*
* better 64-bit) boundary
*/
-unsigned int csum_partial_copy_fromuser( char *src, char *dst, int len, int sum);
+unsigned int csum_partial_copy_fromuser(const char *src, char *dst, int len, int sum);
/*
* This is a version of ip_compute_csum() optimized for IP headers,
--- a/include/asm-i386/dma.h
+++ b/include/asm-i386/dma.h
/* These are in kernel/dma.c: */
-extern int request_dma(unsigned int dmanr, char * device_id); /* reserve a DMA channel */
+extern int request_dma(unsigned int dmanr, const char * device_id); /* reserve a DMA channel */
extern void free_dma(unsigned int dmanr); /* release it again */
--- a/include/asm-mips/dma.h
+++ b/include/asm-mips/dma.h
/* These are in kernel/dma.c: */
-extern int request_dma(unsigned int dmanr, char * device_id); /* reserve a DMA channel */
+extern int request_dma(unsigned int dmanr, const char * device_id); /* reserve a DMA channel */
extern void free_dma(unsigned int dmanr); /* release it again */
--- a/include/linux/bios32.h
+++ b/include/linux/bios32.h
unsigned char where, unsigned short val);
extern pcibios_write_config_dword (unsigned char bus, unsigned char dev_fn,
unsigned char where, unsigned int val);
-extern char *pcibios_strerror (int error);
+extern const char *pcibios_strerror (int error);
#endif /* BIOS32_H */
--- a/include/linux/ext2_fs.h
+++ b/include/linux/ext2_fs.h
extern unsigned long ext2_count_free (struct buffer_head *, unsigned);
/* dir.c */
-extern int ext2_check_dir_entry (char *, struct inode *,
+extern int ext2_check_dir_entry (const char *, struct inode *,
struct ext2_dir_entry *, struct buffer_head *,
unsigned long);
diff --git a/include/linux/fd.hb/include/linux/fd.h
--- a/include/linux/fd.h
+++ b/include/linux/fd.h
rate, /* data rate. |= 0x40 for perpendicular */
spec1, /* stepping rate, head unload time */
fmt_gap; /* gap2 size */
- char * name; /* used only for predefined formats */
+ const char * name; /* used only for predefined formats */
};
struct format_descr {
diff --git a/include/linux/fs.hb/include/linux/fs.h
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
struct file_operations {
int (*lseek) (struct inode *, struct file *, off_t, int);
int (*read) (struct inode *, struct file *, char *, int);
- int (*write) (struct inode *, struct file *, char *, int);
+ int (*write) (struct inode *, struct file *, const char *, int);
int (*readdir) (struct inode *, struct file *, void *, filldir_t);
int (*select) (struct inode *, struct file *, int, select_table *);
int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
struct file_system_type {
struct super_block *(*read_super) (struct super_block *, void *, int);
- char *name;
+ const char *name;
int requires_dev;
struct file_system_type * next;
};
extern struct file_operations write_pipe_fops;
extern struct file_operations rdwr_pipe_fops;
-extern struct file_system_type *get_fs_type(char *name);
+extern struct file_system_type *get_fs_type(const char *name);
extern int fs_may_mount(dev_t dev);
extern int fs_may_umount(dev_t dev, struct inode * mount_root);
extern int block_read(struct inode *, struct file *, char *, int);
extern int read_ahead[];
-extern int char_write(struct inode *, struct file *, char *, int);
-extern int block_write(struct inode *, struct file *, char *, int);
+extern int char_write(struct inode *, struct file *, const char *, int);
+extern int block_write(struct inode *, struct file *, const char *, int);
extern int generic_mmap(struct inode *, struct file *, struct vm_area_struct *);
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
struct gendisk {
int major; /* major number of driver */
- char *major_name; /* name of major driver */
+ const char *major_name; /* name of major driver */
int minor_shift; /* number of times minor is shifted to
get real minor */
int max_p; /* maximum partitions per device */
diff --git a/include/linux/inet.hb/include/linux/inet.h
--- a/include/linux/inet.h
+++ b/include/linux/inet.h
extern void inet_proto_init(struct net_proto *pro);
extern char *in_ntoa(unsigned long in);
-extern unsigned long in_aton(char *str);
+extern unsigned long in_aton(const char *str);
#endif
#endif /* _LINUX_INET_H */
--- a/include/linux/module.h
+++ b/include/linux/module.h
struct internal_symbol {
void *addr;
- char *name;
+ const char *name;
};
struct symbol_table { /* received from "insmod" */
struct module *next;
struct module_ref *ref; /* the list of modules that refer to me */
struct symbol_table *symtab;
- char *name;
+ const char *name;
int size; /* size of module in pages */
void* addr; /* address of module */
int state;
--- a/include/linux/msdos_fs.h
+++ b/include/linux/msdos_fs.h
/* attribute bits that are copied "as is" */
#define DELETED_FLAG 0xe5 /* marks file as deleted when in name[0] */
-#define IS_FREE(n) (!*(n) || *(unsigned char *) (n) == DELETED_FLAG || \
- *(unsigned char *) (n) == FD_FILL_BYTE)
+#define IS_FREE(n) (!*(n) || *(const unsigned char *) (n) == DELETED_FLAG || \
+ *(const unsigned char *) (n) == FD_FILL_BYTE)
#define MSDOS_VALID_MODE (S_IFREG | S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO)
/* valid file mode bits */
/* misc.c */
-extern void fs_panic(struct super_block *s,char *msg);
+extern void fs_panic(struct super_block *s,const char *msg);
extern int is_binary(char conversion,char *extension);
extern void lock_creation(void);
extern void unlock_creation(void);
extern void date_unix2dos(int unix_date,__u16 *time, __u16 *date);
extern int msdos_get_entry(struct inode *dir,loff_t *pos,struct buffer_head **bh,
struct msdos_dir_entry **de);
-extern int msdos_scan(struct inode *dir,char *name,struct buffer_head **res_bh,
+extern int msdos_scan(struct inode *dir,const char *name,struct buffer_head **res_bh,
struct msdos_dir_entry **res_de,int *ino);
extern int msdos_parent_ino(struct inode *dir,int locked);
extern int msdos_subdirs(struct inode *dir);
extern struct inode_operations msdos_file_inode_operations;
extern struct inode_operations msdos_file_inode_operations_1024;
extern int msdos_file_read(struct inode *, struct file *, char *, int);
-extern int msdos_file_write(struct inode *, struct file *, char *, int);
+extern int msdos_file_write(struct inode *, struct file *, const char *, int);
extern struct inode_operations msdos_file_inode_operations_no_bmap;
extern void msdos_truncate(struct inode *inode);
diff --git a/include/linux/net.hb/include/linux/net.h
--- a/include/linux/net.h
+++ b/include/linux/net.h
int *usockaddr_len, int peer);
int (*read) (struct socket *sock, char *ubuf, int size,
int nonblock);
- int (*write) (struct socket *sock, char *ubuf, int size,
+ int (*write) (struct socket *sock, const char *ubuf, int size,
int nonblock);
int (*select) (struct socket *sock, int sel_type,
select_table *wait);
int (*ioctl) (struct socket *sock, unsigned int cmd,
unsigned long arg);
int (*listen) (struct socket *sock, int len);
- int (*send) (struct socket *sock, void *buff, int len, int nonblock,
+ int (*send) (struct socket *sock, const void *buff, int len, int nonblock,
unsigned flags);
int (*recv) (struct socket *sock, void *buff, int len, int nonblock,
unsigned flags);
- int (*sendto) (struct socket *sock, void *buff, int len, int nonblock,
+ int (*sendto) (struct socket *sock, const void *buff, int len, int nonblock,
unsigned flags, struct sockaddr *, int addr_len);
int (*recvfrom) (struct socket *sock, void *buff, int len, int nonblock,
unsigned flags, struct sockaddr *, int *addr_len);
};
struct net_proto {
- char *name; /* Protocol name */
+ const char *name; /* Protocol name */
void (*init_func)(struct net_proto *); /* Bootstrap */
};
extern void dev_add_pack(struct packet_type *pt);
extern void dev_remove_pack(struct packet_type *pt);
-extern struct device *dev_get(char *name);
+extern struct device *dev_get(const char *name);
extern int dev_open(struct device *dev);
extern int dev_close(struct device *dev);
extern void dev_queue_xmit(struct sk_buff *skb, struct device *dev,
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
int offset, int count, char *data,
struct nfs_fattr *fattr, int fs);
extern int nfs_proc_write(struct nfs_server *server, struct nfs_fh *fhandle,
- int offset, int count, char *data,
+ int offset, int count, const char *data,
struct nfs_fattr *fattr);
extern int nfs_proc_create(struct nfs_server *server, struct nfs_fh *dir,
const char *name, struct nfs_sattr *sattr,
diff --git a/include/linux/pci.hb/include/linux/pci.h
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
#define PCI_DEVICE_ID_ADAPTEC_2940 0x7178
#define PCI_DEVICE_ID_ADAPTEC_294x 0x7078
#define PCI_DEVICE_ID_ADAPTEC_7850 0x5078
+#define PCI_DEVICE_ID_ADAPTEC_7872 0x7278
#define PCI_VENDOR_ID_DPT 0x1044
#define PCI_DEVICE_ID_DPT 0xa400
#define PCI_VENDOR_ID_VORTEX 0x1119
#define PCI_DEVICE_ID_VORTEX_GDT 0x0001
+#define PCI_VENDOR_ID_HP 0x103c
+#define PCI_DEVICE_ID_HP_J2585A 0x1030
/*
* The PCI interface treats multi-function devices as independent
extern struct pci_dev_info *pci_lookup_dev (unsigned int vendor,
unsigned int dev);
-extern char *pci_strbioserr (int error);
+extern const char *pci_strbioserr (int error);
extern const char *pci_strclass (unsigned int class);
extern const char *pci_strvendor (unsigned int vendor);
extern const char *pci_strdev (unsigned int vendor, unsigned int device);
* offset of the handler is hard coded in kernel/sys_call.S.
*/
struct exec_domain {
- char *name;
+ const char *name;
lcall7_func handler;
unsigned char pers_low, pers_high;
unsigned long * signal_map;
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
struct proc_dir_entry {
unsigned short low_ino;
unsigned short namelen;
- char * name;
+ const char * name;
};
extern struct super_block *proc_read_super(struct super_block *,void *,int);
--- a/include/linux/smb_fs.h
+++ b/include/linux/smb_fs.h
int smb_proc_read(struct smb_server *server, struct smb_dirent *finfo,
off_t offset, long count, char *data, int fs);
int smb_proc_write(struct smb_server *server, struct smb_dirent *finfo,
- off_t offset, int count, char *data);
+ off_t offset, int count, const char *data);
int smb_proc_create(struct smb_server *server, const char *path,
int len, struct smb_dirent *entry);
int smb_proc_mknew(struct smb_server *server, const char *path, int len,
struct tty_driver {
int magic; /* magic number for this structure */
- char *name;
+ const char *name;
int name_base; /* offset of printed name */
short major; /* major device number */
short minor_start; /* start of minor device number*/
int (*open)(struct tty_struct * tty, struct file * filp);
void (*close)(struct tty_struct * tty, struct file * filp);
int (*write)(struct tty_struct * tty, int from_user,
- unsigned char *buf, int count);
+ const unsigned char *buf, int count);
void (*put_char)(struct tty_struct *tty, unsigned char ch);
void (*flush_chars)(struct tty_struct *tty);
int (*write_room)(struct tty_struct *tty);
int (*read)(struct tty_struct * tty, struct file * file,
unsigned char * buf, unsigned int nr);
int (*write)(struct tty_struct * tty, struct file * file,
- unsigned char * buf, unsigned int nr);
+ const unsigned char * buf, unsigned int nr);
int (*ioctl)(struct tty_struct * tty, struct file * file,
unsigned int cmd, unsigned long arg);
void (*set_termios)(struct tty_struct *tty, struct termios * old);
/*
* The following routines are called from below.
*/
- void (*receive_buf)(struct tty_struct *, unsigned char *cp,
+ void (*receive_buf)(struct tty_struct *, const unsigned char *cp,
char *fp, int count);
int (*receive_room)(struct tty_struct *);
void (*write_wakeup)(struct tty_struct *);
int count);
int umsdos_file_write_kmem (struct inode *inode,
struct file *filp,
- char *buf,
+ const char *buf,
int count);
int umsdos_emd_dir_write (struct inode *emd_dir,
struct file *filp,
diff --git a/include/linux/xd.hb/include/linux/xd.h
--- a/include/linux/xd.h
+++ b/include/linux/xd.h
/* this structure defines a ROM BIOS signature */
typedef struct {
u_long offset;
- char *string;
+ const char *string;
void (*init_controller)(u_char *address);
void (*init_drive)(u_char drive);
- char *name;
+ const char *name;
} XD_SIGNATURE;
u_long xd_init (u_long mem_start,u_long mem_end);
--- a/include/net/datalink.h
+++ b/include/net/datalink.h
struct datalink_proto {
unsigned short type_len;
unsigned char type[8];
- char *string_name;
+ const char *string_name;
unsigned short header_length;
int (*rcvfunc)(struct sk_buff *, struct device *,
struct packet_type *);
diff --git a/include/net/ip.hb/include/net/ip.h
--- a/include/net/ip.h
+++ b/include/net/ip.h
extern int ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen);
extern void ip_init(void);
extern int ip_build_xmit(struct sock *sk,
- void getfrag (void *,
+ void getfrag (const void *,
int,
char *,
unsigned int,
unsigned int),
- void *frag,
+ const void *frag,
unsigned short int length,
int daddr,
int flags,
--- a/include/net/protocol.h
+++ b/include/net/protocol.h
unsigned char protocol;
unsigned char copy:1;
void *data;
- char *name;
+ const char *name;
};
diff --git a/include/net/sock.hb/include/net/sock.h
--- a/include/net/sock.h
+++ b/include/net/sock.h
void (*close)(struct sock *sk, int timeout);
int (*read)(struct sock *sk, unsigned char *to,
int len, int nonblock, unsigned flags);
- int (*write)(struct sock *sk, unsigned char *to,
+ int (*write)(struct sock *sk, const unsigned char *to,
int len, int nonblock, unsigned flags);
int (*sendto)(struct sock *sk,
- unsigned char *from, int len, int noblock,
+ const unsigned char *from, int len, int noblock,
unsigned flags, struct sockaddr_in *usin,
int addr_len);
int (*recvfrom)(struct sock *sk,
diff --git a/init/main.cb/init/main.c
--- a/init/main.c
+++ b/init/main.c
}
struct {
- char *str;
+ const char *str;
void (*setup_func)(char *, int *);
} bootsetups[] = {
{ "reserve=", reserve_setup },
static void parse_options(char *line)
{
char *next;
- static char *devnames[] = { "hda", "hdb", "hdc", "hdd", "sda", "sdb", "sdc", "sdd", "sde", "fd", "xda", "xdb", NULL };
+ static const char *devnames[] = { "hda", "hdb", "hdc", "hdd", "sda", "sdb", "sdc", "sdd", "sde", "fd", "xda", "xdb", NULL };
static int devnums[] = { 0x300, 0x340, 0x1600, 0x1640, 0x800, 0x810, 0x820, 0x830, 0x840, 0x200, 0xD00, 0xD40, 0};
int args, envs;
diff --git a/init/version.cb/init/version.c
--- a/init/version.c
+++ b/init/version.c
UTS_MACHINE, UTS_DOMAINNAME
};
-char *linux_banner =
+const char *linux_banner =
"Linux version " UTS_RELEASE " (" LINUX_COMPILE_BY "@"
LINUX_COMPILE_HOST ") (" LINUX_COMPILER ") " UTS_VERSION "\n";
diff --git a/kernel/dma.cb/kernel/dma.c
--- a/kernel/dma.c
+++ b/kernel/dma.c
struct dma_chan {
int lock;
- char *device_id;
+ const char *device_id;
};
static struct dma_chan dma_chan_busy[MAX_DMA_CHANNELS] = {
} /* get_dma_list */
-int request_dma(unsigned int dmanr, char * device_id)
+int request_dma(unsigned int dmanr, const char * device_id)
{
if (dmanr >= MAX_DMA_CHANNELS)
return -EINVAL;
diff --git a/kernel/itimer.cb/kernel/itimer.c
--- a/kernel/itimer.c
+++ b/kernel/itimer.c
#include <asm/segment.h>
+/*
+ * change timeval to jiffies, trying to avoid the
+ * most obvious overflows..
+ *
+ * The tv_*sec values are signed, but nothing seems to
+ * indicate whether we really should use them as signed values
+ * when doing itimers. POSIX doesn't mention this (but if
+ * alarm() uses itimers without checking, we have to use unsigned
+ * arithmetic).
+ */
static unsigned long tvtojiffies(struct timeval *value)
{
- return((unsigned long )value->tv_sec * HZ +
- (unsigned long )(value->tv_usec + (1000000 / HZ - 1)) /
- (1000000 / HZ));
+ unsigned long sec = (unsigned) value->tv_sec;
+ unsigned long usec = (unsigned) value->tv_usec;
+
+ if (sec > (unsigned) (LONG_MAX / HZ))
+ return LONG_MAX;
+ usec += 1000000 / HZ - 1;
+ usec /= 1000000 / HZ;
+ return HZ*sec+usec;
}
static void jiffiestotv(unsigned long jiffies, struct timeval *value)
diff --git a/kernel/module.cb/kernel/module.c
--- a/kernel/module.c
+++ b/kernel/module.c
int get_module_list(char *buf)
{
char *p;
- char *q;
+ const char *q;
int i;
struct module *mp;
struct module_ref *ref;
diff --git a/kernel/sched.cb/kernel/sched.c
--- a/kernel/sched.c
+++ b/kernel/sched.c
sti();
}
-asmlinkage int sys_alarm(long seconds)
+asmlinkage unsigned int sys_alarm(unsigned int seconds)
{
struct itimerval it_new, it_old;
static void show_task(int nr,struct task_struct * p)
{
unsigned long free;
- static char * stat_nam[] = { "R", "S", "D", "Z", "T", "W" };
+ static const char * stat_nam[] = { "R", "S", "D", "Z", "T", "W" };
printk("%-8s %3d ", p->comm, (p == current) ? -nr : nr);
if (((unsigned) p->state) < sizeof(stat_nam)/sizeof(char *))
diff --git a/lib/vsprintf.cb/lib/vsprintf.c
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
unsigned long num;
int i, base;
char * str;
- char *s;
+ const char *s;
int flags; /* flags to number() */
diff --git a/net/Changesb/net/Changes
--- a/net/Changes
+++ b/net/Changes
o Fixed multicast [IN]
o TCP does rerouting for most cases [NOT WORKING YET]
-------->>>>> 1.3.? <<<<<----------
+------->>>>> 1.3.14 <<<<<----------
+o IPX works [IN]
+o NetROM works [IN]
+o AX.25 works [IN]
+o Most modules need recompiling even though they
+ load OK [BLAME LINUS]
+
+------->>>>> 1.3.15 <<<<<---------
+o Mike Shaver has started RFC1122 verification [IN PROGRESS]
+o Minor bug fixes [IN]
+
+------->>>> ???? <<<--------
o Finish merging the bridge code
o Device locking
o SIOCSLEEPRT patch
diff --git a/net/appletalk/ddp.cb/net/appletalk/ddp.c
--- a/net/appletalk/ddp.c
+++ b/net/appletalk/ddp.c
return(0);
}
-static int atalk_sendto(struct socket *sock, void *ubuf, int len, int noblock,
+static int atalk_sendto(struct socket *sock, const void *ubuf, int len, int noblock,
unsigned flags, struct sockaddr *sat, int addr_len)
{
atalk_socket *sk=(atalk_socket *)sock->data;
return len;
}
-static int atalk_send(struct socket *sock, void *ubuf, int size, int noblock, unsigned flags)
+static int atalk_send(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags)
{
return atalk_sendto(sock,ubuf,size,noblock,flags,NULL,0);
}
@@ -1690,7+1690,7 @@ static int atalk_recvfrom(struct socket *sock, void *ubuf, int size, int noblock
}
-static int atalk_write(struct socket *sock, char *ubuf, int size, int noblock)
+static int atalk_write(struct socket *sock, const char *ubuf, int size, int noblock)
{
return atalk_send(sock,ubuf,size,noblock,0);
}
diff --git a/net/ax25/af_ax25.cb/net/ax25/af_ax25.c
--- a/net/ax25/af_ax25.c
+++ b/net/ax25/af_ax25.c
@@ -1566,7+1566,7 @@ static int bpq_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *
return ax25_rcv(skb, dev, &port_call, ptype);
}
-static int ax25_sendto(struct socket *sock, void *ubuf, int len, int noblock,
+static int ax25_sendto(struct socket *sock, const void *ubuf, int len, int noblock,
unsigned flags, struct sockaddr *usip, int addr_len)
{
struct sock *sk = (struct sock *)sock->data;
@@ -1716,12+1716,12 @@ static int ax25_sendto(struct socket *sock, void *ubuf, int len, int noblock,
}
-static int ax25_send(struct socket *sock, void *ubuf, int size, int noblock, unsigned flags)
+static int ax25_send(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags)
{
return ax25_sendto(sock, ubuf, size, noblock, flags, NULL, 0);
}
-static int ax25_write(struct socket *sock, char *ubuf, int size, int noblock)
+static int ax25_write(struct socket *sock, const char *ubuf, int size, int noblock)
{
return ax25_send(sock, ubuf, size, noblock, 0);
}
{
ax25_cb *ax25;
struct device *dev;
- char *devname;
+ const char *devname;
int len = 0;
off_t pos = 0;
off_t begin = 0;
diff --git a/net/core/dev.cb/net/core/dev.c
--- a/net/core/dev.c
+++ b/net/core/dev.c
* Find an interface by name.
*/
-struct device *dev_get(char *name)
+struct device *dev_get(const char *name)
{
struct device *dev;
diff --git a/net/ipv4/af_inet.cb/net/ipv4/af_inet.c
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
return(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock, 0));
}
-static int inet_send(struct socket *sock, void *ubuf, int size, int noblock,
+static int inet_send(struct socket *sock, const void *ubuf, int size, int noblock,
unsigned flags)
{
struct sock *sk = (struct sock *) sock->data;
/* We may need to bind the socket. */
if(inet_autobind(sk)!=0)
return(-EAGAIN);
- return(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, flags));
+ return(sk->prot->write(sk, (const unsigned char *) ubuf, size, noblock, flags));
}
-static int inet_write(struct socket *sock, char *ubuf, int size, int noblock)
+static int inet_write(struct socket *sock, const char *ubuf, int size, int noblock)
{
return inet_send(sock,ubuf,size,noblock,0);
}
-static int inet_sendto(struct socket *sock, void *ubuf, int size, int noblock,
+static int inet_sendto(struct socket *sock, const void *ubuf, int size, int noblock,
unsigned flags, struct sockaddr *sin, int addr_len)
{
struct sock *sk = (struct sock *) sock->data;
/* We may need to bind the socket. */
if(inet_autobind(sk)!=0)
return -EAGAIN;
- return(sk->prot->sendto(sk, (unsigned char *) ubuf, size, noblock, flags,
+ return(sk->prot->sendto(sk, (const unsigned char *) ubuf, size, noblock, flags,
(struct sockaddr_in *)sin, addr_len));
}
diff --git a/net/ipv4/arp.cb/net/ipv4/arp.c
--- a/net/ipv4/arp.c
+++ b/net/ipv4/arp.c
* Alan Cox : Allow >4K in /proc
* Alan Cox : Make ARP add its own protocol entry
*
- * Ross Martin : Rewrote arp_rcv() and arp_get_info()
+ * Ross Martin : Rewrote arp_rcv() and arp_get_info()
* Stephen Henson : Add AX25 support to arp_get_info()
* Alan Cox : Drop data when a device is downed.
* Alan Cox : Use init_timer().
* Martin Seine : Move the arphdr structure
* to if_arp.h for compatibility.
* with BSD based programs.
- * Andrew Tridgell : Added ARP netmask code and
- * re-arranged proxy handling.
+ * Andrew Tridgell : Added ARP netmask code and
+ * re-arranged proxy handling.
* Alan Cox : Changed to use notifiers.
* Niibe Yutaka : Reply for this device or proxies only.
* Alan Cox : Don't proxy across hardware types!
* Jonathan Naylor : Added support for NET/ROM.
+ * Mike Shaver : RFC1122 checks.
*/
+/* RFC1122 Status:
+ 2.3.2.1 (ARP Cache Validation):
+ MUST provide mechanism to flush stale cache entries (OK)
+ SHOULD be able to configure cache timeout (NOT YET)
+ MUST throttle ARP retransmits (OK)
+ 2.3.2.2 (ARP Packet Queue):
+ SHOULD save at least one packet from each "conversation" with an
+ unresolved IP address. (OK)
+ 950727 -- MS
+*/
+
#include <linux/types.h>
#include <linux/string.h>
#include <linux/kernel.h>
* next request is send.
*/
+/* RFC1122: OK. Throttles ARPing, as per 2.3.2.1. (MUST) */
+/* The recommended minimum timeout is 1 second per destination. */
+/* Is this a per-destination timeout? -- MS [YES AC]*/
+
#define ARP_RES_TIME (250*(HZ/10))
/*
/*
* The last bits in the IP address are used for the cache lookup.
- * A special entry is used for proxy arp entries
+ * A special entry is used for proxy arp entries
*/
#define HASH(paddr) (htonl(paddr) & (ARP_TABLE_SIZE - 1))
* ARP_MAX_TRIES*ARP_RES_TIME.
*/
+/* RFC1122: Looks good. Prevents stale ARP entries, as per 2.3.2.1. (MUST) */
+
static void arp_check_expire(unsigned long dummy)
{
int i;
*pentry = entry->next; /* remove from list */
arp_cache_stamp++;
del_timer(&entry->timer); /* Paranoia */
- kfree_s(entry, sizeof(struct arp_table));
+ kfree_s(entry, sizeof(struct arp_table));
+ /* Don't have to remove packets in entry->skb. */
+ /* See comments above. */
}
else
pentry = &entry->next; /* go to next entry */
/* proxy entries shouldn't really time out so this is really
only here for completeness
*/
+
+ /* RFC1122: They *can* be timed out, according to 2.3.2.1. */
+ /* They recommend a minute. -- MS */
+ /* The world doesn't work this way -- AC */
+
if (entry->flags & ATF_PUBL)
pentry = &arp_tables[PROXY_HASH];
else
/*
* We should never arrive here.
*/
+
+ /* Should we perhaps flush the ARP table (except the ones we're */
+ /* publishing, if we can trust the queue that much) at this */
+ /* point? -- MS */
}
{
printk("arp_send_q: incomplete entry for %s\n",
in_ntoa(entry->ip));
+ /* Can't flush the skb, because RFC1122 says to hang on to */
+ /* at least one from any unresolved entry. --MS */
+ /* Whats happened is that someone has 'unresolved' the entry
+ as we got to use it - this 'can't happen' -- AC */
return;
}
{
kfree_skb(skb, FREE_READ);
return 0;
+ /* Should this be an error/printk? Seems like something */
+ /* you'd want to know about. Unless it's just !IFF_NOARP. -- MS */
}
/*
* match the protocol the device speaks. If it doesn't, there is a
* problem, so toss the packet.
*/
+/* Again, should this be an error/printk? -- MS */
+
switch(dev->type)
{
#ifdef CONFIG_AX25
/*
* Replies to other machines get tossed.
*/
+
+ /* Should we reset the expiry timers for an entry that isn't for us, if we */
+ /* have it in the cache? RFC1122 suggests it. -- MS */
+
kfree_skb(skb, FREE_READ);
return 0;
}
case IS_MULTICAST:
if(dev->type==ARPHRD_ETHER || dev->type==ARPHRD_IEEE802)
{
+ /* What exactly does this do? -- MS */
haddr[0]=0x01;
haddr[1]=0x00;
haddr[2]=0x5e;
if (entry != NULL) /* It exists */
{
- if (!(entry->flags & ATF_COM))
- {
+ if (!(entry->flags & ATF_COM))
+ {
/*
* A request was already send, but no reply yet. Thus
* queue the packet with the previous attempt
entry->last_used = jiffies;
entry->flags = 0;
entry->ip = paddr;
- entry->mask = DEF_ARP_NETMASK;
+ entry->mask = DEF_ARP_NETMASK;
memset(entry->ha, 0, dev->addr_len);
entry->hlen = dev->addr_len;
entry->htype = dev->type;
*start=buffer+(offset-begin); /* Start of wanted data */
len-=(offset-begin); /* Start slop */
if(len>length)
- len=length; /* Ending slop */
+ len=length; /* Ending slop */
return len;
}
/*
* This will find an entry in the ARP table by looking at the IP address.
- * If proxy is PROXY_EXACT then only exact IP matches will be allowed
- * for proxy entries, otherwise the netmask will be used
+ * If proxy is PROXY_EXACT then only exact IP matches will be allowed
+ * for proxy entries, otherwise the netmask will be used
*/
static struct arp_table *arp_lookup(u32 paddr, enum proxy proxy)
if (!entry && proxy != PROXY_NONE)
for (entry=arp_tables[PROXY_HASH]; entry != NULL; entry = entry->next)
if ((proxy==PROXY_EXACT) ? (entry->ip==paddr)
- : !((entry->ip^paddr)&entry->mask))
+ : !((entry->ip^paddr)&entry->mask))
break;
return entry;
if (entry == NULL)
{
- unsigned long hash = HASH(ip);
+ unsigned long hash = HASH(ip);
if (r.arp_flags & ATF_PUBL)
hash = PROXY_HASH;
diff --git a/net/ipv4/icmp.cb/net/ipv4/icmp.c
--- a/net/ipv4/icmp.c
+++ b/net/ipv4/icmp.c
* Alan Cox : Tightened even more.
* Arnt Gulbrandsen: Misplaced #endif with net redirect and break
* A.N.Kuznetsov : ICMP timestamp still used skb+1
+ * Mike Shaver : RFC1122 checks.
*
*
* This program is free software; you can redistribute it and/or
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*/
+
+/* RFC1122 Status: (boy, are there a lot of rules for ICMP)
+ 3.2.2 (Generic ICMP stuff)
+ MUST discard messages of unknown type. (OK)
+ MUST copy at least the first 8 bytes from the offending packet
+ when sending ICMP errors. (OK)
+ MUST pass received ICMP errors up to protocol level. (OK)
+ SHOULD send ICMP errors with TOS == 0. (OK)
+ MUST NOT send ICMP errors in reply to:
+ ICMP errors (OK)
+ Broadcast/multicast datagrams (OK)
+ MAC broadcasts (OK)
+ Non-initial fragments (OK)
+ Datagram with a source address that isn't a single host. (OK)
+ 3.2.2.1 (Destination Unreachable)
+ All the rules govern the IP layer, and are dealt with in ip.c, not here.
+ 3.2.2.2 (Redirect)
+ Host SHOULD NOT send ICMP_REDIRECTs. (OK)
+ MUST update routing table in response to host or network redirects.
+ (host OK, network NOT YET) [Intentionally -- AC]
+ SHOULD drop redirects if they're not from directly connected gateway
+ (OK -- we drop it if it's not from our old gateway, which is close
+ enough)
+ 3.2.2.3 (Source Quench)
+ MUST pass incoming SOURCE_QUENCHs to transport layer (OK)
+ Other requirements are dealt with at the transport layer.
+ 3.2.2.4 (Time Exceeded)
+ MUST pass TIME_EXCEEDED to transport layer (OK)
+ Other requirements dealt with at IP (generating TIME_EXCEEDED).
+ 3.2.2.5 (Parameter Problem)
+ SHOULD generate these, but it doesn't say for what. So we're OK. =)
+ MUST pass received PARAMPROBLEM to transport layer (NOT YET)
+ [Solaris 2.X seems to assert EPROTO when this occurs] -- AC
+ 3.2.2.6 (Echo Request/Reply)
+ MUST reply to ECHO_REQUEST, and give app to do ECHO stuff (OK, OK)
+ MAY discard broadcast ECHO_REQUESTs. (We don't, but that's OK.)
+ MUST reply using same source address as the request was sent to.
+ We're OK for unicast ECHOs, and it doesn't say anything about
+ how to handle broadcast ones, since it's optional.
+ MUST copy data from REQUEST to REPLY (OK)
+ unless it would require illegal fragmentation (MUST) (NOT YET)
+ MUST pass REPLYs to transport/user layer (OK)
+ MUST use any provided source route (reversed) for REPLY. (NOT YET)
+ 3.2.2.7 (Information Request/Reply)
+ MUST NOT implement this. (I guess that means silently discard...?) (OK)
+ 3.2.2.8 (Timestamp Request/Reply)
+ MAY implement (OK)
+ SHOULD be in-kernel for "minimum variability" (OK)
+ MAY discard broadcast REQUESTs. (OK, but see source for inconsistency)
+ MUST reply using same source address as the request was sent to. (OK)
+ MUST reverse source route, as per ECHO (NOT YET)
+ MUST pass REPLYs to transport/user layer (requires RAW, just like ECHO) (OK)
+ MUST update clock for timestamp at least 15 times/sec (OK)
+ MUST be "correct within a few minutes" (OK)
+ 3.2.2.9 (Address Mask Request/Reply)
+ MAY implement (OK)
+ MUST send a broadcast REQUEST if using this system to set netmask
+ (OK... we don't use it)
+ MUST discard received REPLYs if not using this system (OK)
+ MUST NOT send replies unless specifically made agent for this sort
+ of thing. (NOT YET)
+*/
+
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/kernel.h>
icmp_statistics.IcmpOutSrcQuenchs++;
break;
case ICMP_REDIRECT:
+ /* RFC1122: (3.2.2.2) Sorta bad. SHOULDN'T send */
+ /* ICMP_REDIRECTs unless we're a gateway. -- MS */
+ /* We don't .. this path isnt invoked -- AC */
icmp_statistics.IcmpOutRedirects++;
break;
case ICMP_ECHO:
@@ -227,6+294,11 @@ void icmp_send(struct sk_buff *skb_in, int type, int code, unsigned long info, s
*/
our_addr = dev->pa_addr;
+
+ /* RFC1122: (3.2.2). MUST NOT send ICMP in reply to */
+ /* packet with a source IP address that doesn't define a single */
+ /* host. -- MS. Checked higher up -- AC */
+
if (iph->daddr != our_addr && ip_chk_addr(iph->daddr) == IS_MYADDR)
our_addr = iph->daddr;
offset = ip_build_header(skb, our_addr, iph->saddr,
* Fill in the frame
*/
+ /* RFC1122: SHOULD send with TOS == 0, and I guess this does. */
+ /* Perhaps it should be explicit? -- MS */
+
icmph = (struct icmphdr *) (skb->data + offset);
icmph->type = type;
icmph->code = code;
icmph->un.gateway = info; /* This might not be meant for
this form of the union but it will
be right anyway */
+
+ /* RFC1122: OK. Copies the minimum 8 bytes unchanged from the offending */
+ /* packet (MUST) as per 3.2.2. -- MS */
memcpy(icmph + 1, iph, sizeof(struct iphdr) + 8);
icmph->checksum = ip_compute_csum((unsigned char *)icmph,
/*
* Pass it off to everyone who wants it.
*/
+
+ /* RFC1122: OK. Passes appropriate ICMP errors to the */
+ /* appropriate protocol layer (MUST), as per 3.2.2. */
+
if (iph->protocol == ipprot->protocol && ipprot->err_handler)
{
ipprot->err_handler(err, (unsigned char *)(icmph + 1),
*/
icmphr = (struct icmphdr *) (skb2->data + offset);
memcpy((char *) icmphr, (char *) icmph, len);
+
+ /* Are we copying the data from the ECHO datagram? */
+ /* We're supposed to, and it looks like we are. -- MS */
+ /* We're also supposed to truncate it if it would force */
+ /* illegal fragmentation. *sigh* */
+
icmphr->type = ICMP_ECHOREPLY;
icmphr->code = 0;
icmphr->checksum = 0;
@@ -587,11+675,20 @@ static void icmp_info(struct icmphdr *icmph, struct sk_buff *skb, struct device
/*
* Handle ICMP_ADDRESS_MASK requests.
*/
+
+/* RFC1122 (3.2.2.9). A host MUST only send replies to */
+/* ADDRESS_MASK requests if it's been configured as an address mask */
+/* agent. Receiving a request doesn't constitute implicit permission to */
+/* act as one. Of course, implementing this correctly requires (SHOULD) */
+/* a way to turn the functionality on and off. Another one for sysctl(), */
+/* I guess. -- MS */
+/* Botched with a CONFIG option for now - Linus add scts sysctl please.. */
static void icmp_address(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
unsigned long saddr, unsigned long daddr, int len,
struct options *opt)
{
+#ifdef CONFIG_IP_ADDR_AGENT
struct icmphdr *icmphr;
struct sk_buff *skb2;
int size, offset;
/* Ship it out - free it when done */
ip_queue_xmit((struct sock *)NULL, ndev, skb2, 1);
-
+#endif
skb->sk = NULL;
kfree_skb(skb, FREE_READ);
}
if (ip_chk_addr(daddr) != IS_MYADDR)
{
if (icmph->type != ICMP_ECHO)
+ /* RFC1122: We're allowed to reply to ICMP_TIMESTAMP */
+ /* requests in the same manner as ICMP_ECHO (optionally */
+ /* drop those to a bcast/mcast), so perhaps we should be */
+ /* consistent? -- MS */
+
{
icmp_statistics.IcmpInErrors++;
kfree_skb(skb1, FREE_READ);
icmp_timestamp(icmph, skb1, dev, saddr, daddr, len, opt);
return 0;
case ICMP_TIMESTAMPREPLY:
+ /* RFC1122: MUST pass TIMESTAMPREPLY messages up to app layer, */
+ /* just as with ECHOREPLY. You have to use raw to get that */
+ /* functionality, just as with ECHOREPLY. Close enough. -- MS */
icmp_statistics.IcmpInTimestampReps++;
kfree_skb(skb1,FREE_READ);
return 0;
kfree_skb(skb1, FREE_READ);
return(0);
default:
+ /* RFC1122: OK. Silently discarding weird ICMP (MUST), */
+ /* as per 3.2.2. -- MS */
icmp_statistics.IcmpInErrors++;
kfree_skb(skb1, FREE_READ);
return(0);
diff --git a/net/ipv4/ip.cb/net/ipv4/ip.c
--- a/net/ipv4/ip.c
+++ b/net/ipv4/ip.c
@@ -2346,12+2346,12 @@ int ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *op
*/
int ip_build_xmit(struct sock *sk,
- void getfrag (void *,
+ void getfrag (const void *,
int,
char *,
unsigned int,
unsigned int),
- void *frag,
+ const void *frag,
unsigned short int length,
int daddr,
int flags,
diff --git a/net/ipv4/ip_fw.cb/net/ipv4/ip_fw.c
--- a/net/ipv4/ip_fw.c
+++ b/net/ipv4/ip_fw.c
*/
static unsigned short masq_port = PORT_MASQ_BEGIN;
-static char *strProt[] = {"UDP","TCP"};
+static const char *strProt[] = {"UDP","TCP"};
struct ip_masq *ip_msq_hosts;
#endif
diff --git a/net/ipv4/packet.cb/net/ipv4/packet.c
--- a/net/ipv4/packet.c
+++ b/net/ipv4/packet.c
* protocol layers and you must therefore supply it with a complete frame
*/
-static int packet_sendto(struct sock *sk, unsigned char *from, int len,
+static int packet_sendto(struct sock *sk, const unsigned char *from, int len,
int noblock, unsigned flags, struct sockaddr_in *usin,
int addr_len)
{
* always fail but we include it for completeness and future expansion.
*/
-static int packet_write(struct sock *sk, unsigned char *buff,
+static int packet_write(struct sock *sk, const unsigned char *buff,
int len, int noblock, unsigned flags)
{
return(packet_sendto(sk, buff, len, noblock, flags, NULL, 0));
diff --git a/net/ipv4/raw.cb/net/ipv4/raw.c
--- a/net/ipv4/raw.c
+++ b/net/ipv4/raw.c
@@ -127,18+127,18 @@ int raw_rcv(struct sock *sk, struct sk_buff *skb, struct device *dev, long saddr
* Callback support is trivial for SOCK_RAW
*/
-static void raw_getfrag(void *p, int saddr, char *to, unsigned int offset, unsigned int fraglen)
+static void raw_getfrag(const void *p, int saddr, char *to, unsigned int offset, unsigned int fraglen)
{
- memcpy_fromfs(to, (unsigned char *)p+offset, fraglen);
+ memcpy_fromfs(to, (const unsigned char *)p+offset, fraglen);
}
/*
* IPPROTO_RAW needs extra work.
*/
-static void raw_getrawfrag(void *p, int saddr, char *to, unsigned int offset, unsigned int fraglen)
+static void raw_getrawfrag(const void *p, int saddr, char *to, unsigned int offset, unsigned int fraglen)
{
- memcpy_fromfs(to, (unsigned char *)p+offset, fraglen);
+ memcpy_fromfs(to, (const unsigned char *)p+offset, fraglen);
if(offset==0)
{
struct iphdr *iph=(struct iphdr *)to;
}
}
-static int raw_sendto(struct sock *sk, unsigned char *from,
+static int raw_sendto(struct sock *sk, const unsigned char *from,
int len, int noblock, unsigned flags, struct sockaddr_in *usin, int addr_len)
{
int err;
}
-static int raw_write(struct sock *sk, unsigned char *buff, int len, int noblock,
+static int raw_write(struct sock *sk, const unsigned char *buff, int len, int noblock,
unsigned flags)
{
return(raw_sendto(sk, buff, len, noblock, flags, NULL, 0));
diff --git a/net/ipv4/tcp.cb/net/ipv4/tcp.c
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
* of two things. Firstly we will bin packets even within the window
* in order to get the data we are waiting for into the memory limit.
* Secondly we bin common duplicate forms at receive time
- * Better heuristics welcome
+ * Better heuristics welcome
*/
int tcp_select_window(struct sock *sk)
@@ -1456,7+1456,7 @@ extern __inline int tcp_build_header(struct tcphdr *th, struct sock *sk, int pus
* and starts the transmit system.
*/
-static int tcp_write(struct sock *sk, unsigned char *from,
+static int tcp_write(struct sock *sk, const unsigned char *from,
int len, int nonblock, unsigned flags)
{
int copied = 0;
if ((skb = tcp_dequeue_partial(sk)) != NULL)
{
- int hdrlen;
+ int hdrlen;
- /* IP header + TCP header */
+ /* IP header + TCP header */
hdrlen = ((unsigned long)skb->h.th - (unsigned long)skb->data)
- + sizeof(struct tcphdr);
+ + sizeof(struct tcphdr);
/* Add more stuff to the end of skb->len */
if (!(flags & MSG_OOB))
* This is just a wrapper.
*/
-static int tcp_sendto(struct sock *sk, unsigned char *from,
+static int tcp_sendto(struct sock *sk, const unsigned char *from,
int len, int nonblock, unsigned flags,
struct sockaddr_in *addr, int addr_len)
{
@@ -2586,10+2586,10 @@ static void tcp_reset(unsigned long saddr, unsigned long daddr, struct tcphdr *t
/*
* Look for tcp options. Parses everything but only knows about MSS.
- * This routine is always called with the packet containing the SYN.
- * However it may also be called with the ack to the SYN. So you
- * can't assume this is always the SYN. It's always called after
- * we have set up sk->mtu to our own MTU.
+ * This routine is always called with the packet containing the SYN.
+ * However it may also be called with the ack to the SYN. So you
+ * can't assume this is always the SYN. It's always called after
+ * we have set up sk->mtu to our own MTU.
*
* We need at minimum to add PAWS support here. Possibly large windows
* as Linux gets deployed on 100Mb/sec networks.
@@ -3452,7+3452,7 @@ extern __inline__ int tcp_ack(struct sock *sk, struct tcphdr *th, unsigned long
sk->backoff = 0;
}
flag |= (2|4); /* 2 is really more like 'don't adjust the rtt
- In this case as we just set it up */
+ In this case as we just set it up */
cli();
oskb = sk->send_head;
IS_SKB(oskb);
@@ -3495,7+3495,7 @@ extern __inline__ int tcp_ack(struct sock *sk, struct tcphdr *th, unsigned long
if (skb_peek(&sk->write_queue) != NULL)
{
if (after (sk->window_seq+1, sk->write_queue.next->h.seq) &&
- (sk->retransmits == 0 ||
+ (sk->retransmits == 0 ||
sk->ip_xmit_timeout != TIME_WRITE ||
before(sk->write_queue.next->h.seq, sk->rcv_ack_seq + 1))
&& sk->packets_out < sk->cong_window)
@@ -3514,7+3514,7 @@ extern __inline__ int tcp_ack(struct sock *sk, struct tcphdr *th, unsigned long
/*
* Data to queue but no room.
*/
- reset_xmit_timer(sk, TIME_PROBE0, sk->rto);
+ reset_xmit_timer(sk, TIME_PROBE0, sk->rto);
}
}
else
diff --git a/net/ipv4/udp.cb/net/ipv4/udp.c
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
* Alan Cox : Cache last socket
* Alan Cox : Route cache
* Jon Peatfield : Minor efficientcy fix to sendto().
+ * Mike Shaver : RFC1122 checks.
*
*
* This program is free software; you can redistribute it and/or
* 2 of the License, or (at your option) any later version.
*/
+/* RFC1122 Status:
+ 4.1.3.1 (Ports):
+ SHOULD send ICMP_PORT_UNREACHABLE in reponse to datagrams to
+ an un-listened port. (OK)
+ 4.1.3.2 (IP Options)
+ MUST pass IP options from IP -> application (OK)
+ MUST allow application to specify IP options (OK)
+ 4.1.3.3 (ICMP Messages)
+ MUST pass ICMP error messages to application (OK)
+ 4.1.3.4 (UDP Checksums)
+ MUST provide facility for checksumming (OK)
+ MAY allow application to control checksumming (OK)
+ MUST default to checksumming on (OK)
+ MUST discard silently datagrams with bad csums (OK)
+ 4.1.3.5 (UDP Multihoming)
+ MUST allow application to specify source address (OK)
+ SHOULD be able to communicate the chosen src addr up to application
+ when application doesn't choose (NOT YET - doesnt seem to be in the BSD API)
+ [Does opening a SOCK_PACKET and snooping your output count 8)]
+ 4.1.3.6 (Invalid Addresses)
+ MUST discard invalid source addresses (NOT YET -- will be implemented
+ in IP, so UDP will eventually be OK. Right now it's a violation.)
+ MUST only send datagrams with one of our addresses (NOT YET - ought to be OK )
+ 950728 -- MS
+*/
+
#include <asm/system.h>
#include <asm/segment.h>
#include <linux/types.h>
#include <net/checksum.h>
/*
- * SNMP MIB for the UDP layer
+ * Snmp MIB for the UDP layer
*/
struct udp_mib udp_statistics;
* client code people.
*/
+ /* RFC1122: OK. Passes ICMP errors back to application, as per */
+ /* 4.1.3.3. */
+ /* After the comment above, that should be no surprise. */
+
if (icmp_err_convert[err & 0xff].fatal)
{
sk->err = icmp_err_convert[err & 0xff].errno;
struct udphdr uh;
int daddr;
int other;
- char *from;
+ const char *from;
int wcheck;
};
* for direct user->board I/O transfers. That one will be fun.
*/
-static void udp_getfrag(void *p, int saddr, char * to, unsigned int offset, unsigned int fraglen)
+static void udp_getfrag(const void *p, int saddr, char * to, unsigned int offset, unsigned int fraglen)
{
struct udpfakehdr *ufh = (struct udpfakehdr *)p;
- char *src, *dst;
+ const char *src;
+ char *dst;
unsigned int len;
if (offset)
@@ -225,10+257,11 @@ static void udp_getfrag(void *p, int saddr, char * to, unsigned int offset, unsi
* this is a valid decision.
*/
-static void udp_getfrag_nosum(void *p, int saddr, char * to, unsigned int offset, unsigned int fraglen)
+static void udp_getfrag_nosum(const void *p, int saddr, char * to, unsigned int offset, unsigned int fraglen)
{
struct udpfakehdr *ufh = (struct udpfakehdr *)p;
- char *src, *dst;
+ const char *src;
+ char *dst;
unsigned int len;
if (offset)
*/
static int udp_send(struct sock *sk, struct sockaddr_in *sin,
- unsigned char *from, int len, int rt)
+ const unsigned char *from, int len, int rt)
{
int ulen = len + sizeof(struct udphdr);
int a;
ufh.other = (htons(ulen) << 16) + IPPROTO_UDP*256;
ufh.from = from;
ufh.wcheck = 0;
+
+ /* RFC1122 Violation: there is no provision for passing IP options */
+ /* from the application layer to the IP one. It's a MUST (4.1.3.2), */
+ /* but it looks like it'd require some work on ip_build_xmit. */
+ /* Alan says he's got a Cunning Plan. -- MS */
+
+ /* RFC1122: OK. Provides the checksumming facility (MUST) as per */
+ /* 4.1.3.4. It's configurable by the application via setsockopt() */
+ /* (MAY) and it defaults to on (MUST). Almost makes up for the */
+ /* violation above. -- MS */
+
if(sk->no_check)
a = ip_build_xmit(sk, udp_getfrag_nosum, &ufh, ulen,
sin->sin_addr.s_addr, rt, IPPROTO_UDP);
}
-static int udp_sendto(struct sock *sk, unsigned char *from, int len, int noblock,
+static int udp_sendto(struct sock *sk, const unsigned char *from, int len, int noblock,
unsigned flags, struct sockaddr_in *usin, int addr_len)
{
struct sockaddr_in sin;
@@ -320,6+364,16 @@ static int udp_sendto(struct sock *sk, unsigned char *from, int len, int noblock
* broadcasting of data.
*/
+ /* RFC1122: OK. Allows the application to select the specific */
+ /* source address for an outgoing packet (MUST) as per 4.1.3.5. */
+ /* Optional addition: a mechanism for telling the application what */
+ /* address was used. (4.1.3.5, MAY) -- MS */
+
+ /* RFC1122: MUST ensure that all outgoing packets have one */
+ /* of this host's addresses as a source addr.(4.1.3.6) - bind in */
+ /* af_inet.c checks these. It does need work to allow BSD style */
+ /* bind to multicast as is done by xntpd */
+
if(usin->sin_addr.s_addr==INADDR_ANY)
usin->sin_addr.s_addr=ip_my_addr();
* In BSD SOCK_DGRAM a write is just like a send.
*/
-static int udp_write(struct sock *sk, unsigned char *buff, int len, int noblock,
+static int udp_write(struct sock *sk, const unsigned char *buff, int len, int noblock,
unsigned flags)
{
return(udp_sendto(sk, buff, len, noblock, flags, NULL, 0));
return(0);
}
+ /* RFC1122 warning: According to 4.1.3.6, we MUST discard any */
+ /* datagram which has an invalid source address, either here or */
+ /* in IP. */
+ /* Right now, IP isn't doing it, and neither is UDP. It's on the */
+ /* FIXME list for IP, though, so I wouldn't worry about it. */
+ /* (That's the Right Place to do it, IMHO.) -- MS */
+
if (uh->check && (
( skb->ip_summed && udp_check(uh, len, saddr, daddr, skb->csum ) ) ||
( !skb->ip_summed && udp_check(uh, len, saddr, daddr,csum_partial((char*)uh, len, 0)))
{
/* <mea@utu.fi> wants to know, who sent it, to
go and stomp on the garbage sender... */
+
+ /* RFC1122: OK. Discards the bad packet silently (as far as */
+ /* the network is concered, anyway) as per 4.1.3.4 (MUST). */
+
NETDEBUG(printk("UDP: bad checksum. From %08lX:%d to %08lX:%d ulen %d\n",
ntohl(saddr),ntohs(uh->source),
ntohl(daddr),ntohs(uh->dest),
* Charge it to the socket, dropping if the queue is full.
*/
+ /* I assume this includes the IP options, as per RFC1122 (4.1.3.2). */
+ /* If not, please let me know. -- MS */
+
if (sock_queue_rcv_skb(sk,skb)<0)
{
udp_statistics.UdpInErrors++;
0, 0,
{NULL,}
};
-
diff --git a/net/ipv4/utils.cb/net/ipv4/utils.c
--- a/net/ipv4/utils.c
+++ b/net/ipv4/utils.c
* Convert an ASCII string to binary IP.
*/
-unsigned long in_aton(char *str)
+unsigned long in_aton(const char *str)
{
unsigned long l;
unsigned int val;
diff --git a/net/ipx/af_ipx.cb/net/ipx/af_ipx.c
--- a/net/ipx/af_ipx.c
+++ b/net/ipx/af_ipx.c
return ipxrtr_add_route(intrfc->if_netnum, intrfc, NULL);
}
-static char * ipx_frame_name(unsigned short);
-static char * ipx_device_name(ipx_interface *);
+static const char * ipx_frame_name(unsigned short);
+static const char * ipx_device_name(ipx_interface *);
static int ipxrtr_route_skb(struct sk_buff *);
static int
}
static int
-ipxrtr_route_packet(ipx_socket *sk, struct sockaddr_ipx *usipx, void *ubuf, int len)
+ipxrtr_route_packet(ipx_socket *sk, struct sockaddr_ipx *usipx, const void *ubuf, int len)
{
struct sk_buff *skb;
ipx_interface *intrfc;
}
}
-static char *
+static const char *
ipx_frame_name(unsigned short frame)
{
switch (ntohs(frame)) {
}
}
-static char *
+static const char *
ipx_device_name(ipx_interface *intrfc)
{
return (intrfc->if_internal ? "Internal" :
return ipxitf_rcv(intrfc, skb);
}
-static int ipx_sendto(struct socket *sock, void *ubuf, int len, int noblock,
+static int ipx_sendto(struct socket *sock, const void *ubuf, int len, int noblock,
unsigned flags, struct sockaddr *usip, int addr_len)
{
ipx_socket *sk=(ipx_socket *)sock->data;
return len;
}
-static int ipx_send(struct socket *sock, void *ubuf, int size, int noblock, unsigned flags)
+static int ipx_send(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags)
{
return ipx_sendto(sock,ubuf,size,noblock,flags,NULL,0);
}
@@ -1780,7+1780,7 @@ static int ipx_recvfrom(struct socket *sock, void *ubuf, int size, int noblock,
return(truesize);
}
-static int ipx_write(struct socket *sock, char *ubuf, int size, int noblock)
+static int ipx_write(struct socket *sock, const char *ubuf, int size, int noblock)
{
return ipx_send(sock,ubuf,size,noblock,0);
}
--- a/net/netrom/af_netrom.c
+++ b/net/netrom/af_netrom.c
return 1;
}
-static int nr_sendto(struct socket *sock, void *ubuf, int len, int noblock,
+static int nr_sendto(struct socket *sock, const void *ubuf, int len, int noblock,
unsigned flags, struct sockaddr *usip, int addr_len)
{
struct sock *sk = (struct sock *)sock->data;
return len;
}
-static int nr_send(struct socket *sock, void *ubuf, int size, int noblock, unsigned flags)
+static int nr_send(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags)
{
return nr_sendto(sock, ubuf, size, noblock, flags, NULL, 0);
}
-static int nr_write(struct socket *sock, char *ubuf, int size, int noblock)
+static int nr_write(struct socket *sock, const char *ubuf, int size, int noblock)
{
return nr_send(sock, ubuf, size, noblock, 0);
}
{
struct sock *s;
struct device *dev;
- char *devname;
+ const char *devname;
int len = 0;
off_t pos = 0;
off_t begin = 0;
--- a/net/netrom/nr_route.c
+++ b/net/netrom/nr_route.c
* Add a new route to a node, and in the process add the node and the
* neighbour if it is new.
*/
-static int nr_add_node(ax25_address *nr, char *mnemonic, ax25_address *ax25,
+static int nr_add_node(ax25_address *nr, const char *mnemonic, ax25_address *ax25,
ax25_digi *ax25_digi, struct device *dev, int quality, int obs_count)
{
struct nr_node *nr_node;
diff --git a/net/socket.cb/net/socket.c
--- a/net/socket.c
+++ b/net/socket.c
int whence);
static int sock_read(struct inode *inode, struct file *file, char *buf,
int size);
-static int sock_write(struct inode *inode, struct file *file, char *buf,
+static int sock_write(struct inode *inode, struct file *file, const char *buf,
int size);
static void sock_close(struct inode *inode, struct file *file);
* readable by the user process.
*/
-static int sock_write(struct inode *inode, struct file *file, char *ubuf, int size)
+static int sock_write(struct inode *inode, struct file *file, const char *ubuf, int size)
{
struct socket *sock;
int err;
diff --git a/net/unix/sock.cb/net/unix/sock.c
--- a/net/unix/sock.c
+++ b/net/unix/sock.c
int *usockaddr_len, int peer);
static int unix_proto_read(struct socket *sock, char *ubuf, int size,
int nonblock);
-static int unix_proto_write(struct socket *sock, char *ubuf, int size,
+static int unix_proto_write(struct socket *sock, const char *ubuf, int size,
int nonblock);
static int unix_proto_select(struct socket *sock, int sel_type, select_table * wait);
static int unix_proto_ioctl(struct socket *sock, unsigned int cmd,
unsigned long arg);
static int unix_proto_listen(struct socket *sock, int backlog);
-static int unix_proto_send(struct socket *sock, void *buff, int len,
+static int unix_proto_send(struct socket *sock, const void *buff, int len,
int nonblock, unsigned flags);
static int unix_proto_recv(struct socket *sock, void *buff, int len,
int nonblock, unsigned flags);
-static int unix_proto_sendto(struct socket *sock, void *buff, int len,
+static int unix_proto_sendto(struct socket *sock, const void *buff, int len,
int nonblock, unsigned flags,
struct sockaddr *addr, int addr_len);
static int unix_proto_recvfrom(struct socket *sock, void *buff, int len,
* SendTo() doesn't matter as we also have no Datagram support!
*/
-static int unix_proto_sendto(struct socket *sock, void *buff, int len, int nonblock,
+static int unix_proto_sendto(struct socket *sock, const void *buff, int len, int nonblock,
unsigned flags, struct sockaddr *addr, int addr_len)
{
return(-EOPNOTSUPP);
* Send data to a unix socket.
*/
-static int unix_proto_send(struct socket *sock, void *buff, int len, int nonblock,
+static int unix_proto_send(struct socket *sock, const void *buff, int len, int nonblock,
unsigned flags)
{
if (flags != 0)
return(-EINVAL);
- return(unix_proto_write(sock, (char *) buff, len, nonblock));
+ return(unix_proto_write(sock, (const char *) buff, len, nonblock));
}
* peer has disconnected, which we check other ways.
*/
-static int unix_proto_write(struct socket *sock, char *ubuf, int size, int nonblock)
+static int unix_proto_write(struct socket *sock, const char *ubuf, int size, int nonblock)
{
struct unix_proto_data *pupd;
int todo, space;
