Skip to content

L
linux
Commit 994b3fb0 authored by Benjamin LaHaise's avatar Benjamin LaHaise
Browse files
Options

Merge redhat.com:/md0/linus-2.5 into redhat.com:/md0/aio-2.5

parents ecb796f5 469d2810
Show whitespace changes
Inline Side-by-side
Showing with 1965 additions and 2280 deletions
MAINTAINERS
View file @ 994b3fb0
......@@ -738,7 +738,7 @@ S: Maintained
IBM ServeRAID RAID DRIVER
P: Jack Hammer
P: Dave Jeffrey
P: Dave Jeffery
M: ipslinux@adaptec.com
W: http://www.developer.ibm.com/welcome/netfinity/serveraid.html
S: Supported
......
arch/alpha/Config.help
View file @ 994b3fb0
......@@ -251,6 +251,10 @@ CONFIG_ALPHA_PRIMO
CONFIG_ALPHA_GAMMA
Say Y if you have an AS 2000 5/xxx or an AS 2100 5/xxx.
CONFIG_ALPHA_EV67
Is this a machine based on the EV67 core? If in doubt, select N here
and the machine will be treated as an EV6.
CONFIG_ALPHA_SRM
There are two different types of booting firmware on Alphas: SRM,
which is command line driven, and ARC, which uses menus and arrow
......@@ -610,3 +614,14 @@ CONFIG_DEBUG_SPINLOCK
best used in conjunction with the NMI watchdog so that spinlock
deadlocks are also debuggable.
CONFIG_DEBUG_RWLOCK
If you say Y here then read-write lock processing will count how many
times it has tried to get the lock and issue an error message after
too many attempts. If you suspect a rwlock problem or a kernel
hacker asks for this option then say Y. Otherwise say N.
CONFIG_DEBUG_SEMAPHORE
If you say Y here then semaphore processing will issue lots of
verbose debugging messages. If you suspect a semaphore problem or a
kernel hacker asks for this option then say Y. Otherwise say N.
arch/alpha/Makefile
View file @ 994b3fb0
......@@ -99,30 +99,32 @@ export libs-y
MAKEBOOT = $(MAKE) -C arch/alpha/boot
rawboot:
rawboot: vmlinux
@$(MAKEBOOT) rawboot
boot: vmlinux
@$(MAKEBOOT)
#
# My boot writes directly to a specific disk partition, I doubt most
# people will want to do that without changes..
#
msb my-special-boot:
msb my-special-boot: vmlinux
@$(MAKEBOOT) msb
bootimage:
bootimage: vmlinux
@$(MAKEBOOT) bootimage
srmboot:
srmboot: vmlinux
@$(MAKEBOOT) srmboot
archclean:
@$(MAKE) -C arch/alpha/kernel clean
@$(MAKEBOOT) clean
archmrproper:
rm -f include/asm-alpha/asm_offsets.h
bootpfile:
bootpfile: vmlinux
@$(MAKEBOOT) bootpfile
......
arch/alpha/boot/Makefile
View file @ 994b3fb0
......@@ -8,7 +8,9 @@
# Copyright (C) 1994 by Linus Torvalds
#
LINKFLAGS = -static -T bootloader.lds #-N -relax
LINKFLAGS = -static -T bootloader.lds -uvsprintf #-N -relax
CFLAGS := $(CFLAGS) -I$(TOPDIR)/include
.S.s:
$(CPP) $(AFLAGS) -traditional -o $*.o $<
......
arch/alpha/kernel/Makefile
View file @ 994b3fb0
......@@ -8,8 +8,9 @@ EXTRA_AFLAGS := $(CFLAGS)
export-objs := alpha_ksyms.o
obj-y := entry.o traps.o process.o init_task.o osf_sys.o irq.o irq_alpha.o \
signal.o setup.o ptrace.o time.o semaphore.o alpha_ksyms.o
obj-y := entry.o traps.o process.o init_task.o osf_sys.o irq.o \
irq_alpha.o signal.o setup.o ptrace.o time.o semaphore.o \
alpha_ksyms.o systbls.o
#
# FIXME!
......
arch/alpha/kernel/alpha_ksyms.c
View file @ 994b3fb0
......@@ -161,7 +161,6 @@ EXPORT_SYMBOL(sys_read);
EXPORT_SYMBOL(sys_lseek);
EXPORT_SYMBOL(__kernel_execve);
EXPORT_SYMBOL(sys_setsid);
EXPORT_SYMBOL(sys_sync);
EXPORT_SYMBOL(sys_wait4);
/* Networking helper routines. */
......
arch/alpha/kernel/entry.S
View file @ 994b3fb0
......@@ -9,8 +9,7 @@
#include <asm/cache.h>
#include <asm/asm_offsets.h>
#include <asm/thread_info.h>
#define NR_SYSCALLS 381
#include <asm/unistd.h>
/*
* stack offsets
......@@ -677,6 +676,7 @@ ret_success:
.end entSys
.align 3
.globl sys_sigreturn
.ent sys_sigreturn
sys_sigreturn:
mov $30,$17
......@@ -688,6 +688,7 @@ sys_sigreturn:
.end sys_sigreturn
.align 3
.globl sys_rt_sigreturn
.ent sys_rt_sigreturn
sys_rt_sigreturn:
mov $30,$17
......@@ -699,6 +700,7 @@ sys_rt_sigreturn:
.end sys_rt_sigreturn
.align 3
.globl sys_sigsuspend
.ent sys_sigsuspend
sys_sigsuspend:
mov $30,$17
......@@ -713,6 +715,7 @@ sys_sigsuspend:
.end sys_sigsuspend
.align 3
.globl sys_rt_sigsuspend
.ent sys_rt_sigsuspend
sys_rt_sigsuspend:
mov $30,$18
......@@ -725,421 +728,3 @@ sys_rt_sigsuspend:
lda $30,SWITCH_STACK_SIZE+16($30)
ret $31,($26),1
.end sys_rt_sigsuspend
.data
.align 3
.globl sys_call_table
sys_call_table:
.quad alpha_ni_syscall /* 0 */
.quad sys_exit
.quad sys_fork
.quad sys_read
.quad sys_write
.quad alpha_ni_syscall /* 5 */
.quad sys_close
.quad osf_wait4
.quad alpha_ni_syscall
.quad sys_link
.quad sys_unlink /* 10 */
.quad alpha_ni_syscall
.quad sys_chdir
.quad sys_fchdir
.quad sys_mknod
.quad sys_chmod /* 15 */
.quad sys_chown
.quad osf_brk
.quad alpha_ni_syscall
.quad sys_lseek
.quad sys_getxpid /* 20 */
.quad osf_mount
.quad sys_umount
.quad sys_setuid
.quad sys_getxuid
.quad alpha_ni_syscall /* 25 */
.quad sys_ptrace
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 30 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad sys_access
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 35 */
.quad sys_sync
.quad sys_kill
.quad alpha_ni_syscall
.quad sys_setpgid
.quad alpha_ni_syscall /* 40 */
.quad sys_dup
.quad sys_pipe
.quad osf_set_program_attributes
.quad alpha_ni_syscall
.quad sys_open /* 45 */
.quad alpha_ni_syscall
.quad sys_getxgid
.quad osf_sigprocmask
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 50 */
.quad sys_acct
.quad sys_sigpending
.quad alpha_ni_syscall
.quad sys_ioctl
.quad alpha_ni_syscall /* 55 */
.quad alpha_ni_syscall
.quad sys_symlink
.quad sys_readlink
.quad sys_execve
.quad sys_umask /* 60 */
.quad sys_chroot
.quad alpha_ni_syscall
.quad sys_getpgrp
.quad sys_getpagesize
.quad alpha_ni_syscall /* 65 */
.quad sys_vfork
.quad sys_newstat
.quad sys_newlstat
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 70 */
.quad osf_mmap
.quad alpha_ni_syscall
.quad sys_munmap
.quad sys_mprotect
.quad sys_madvise /* 75 */
.quad sys_vhangup
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad sys_getgroups
/* map BSD's setpgrp to sys_setpgid for binary compatibility: */
.quad sys_setgroups /* 80 */
.quad alpha_ni_syscall
.quad sys_setpgid
.quad osf_setitimer
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 85 */
.quad osf_getitimer
.quad sys_gethostname
.quad sys_sethostname
.quad sys_getdtablesize
.quad sys_dup2 /* 90 */
.quad sys_newfstat
.quad sys_fcntl
.quad osf_select
.quad sys_poll
.quad sys_fsync /* 95 */
.quad sys_setpriority
.quad sys_socket
.quad sys_connect
.quad sys_accept
.quad osf_getpriority /* 100 */
.quad sys_send
.quad sys_recv
.quad sys_sigreturn
.quad sys_bind
.quad sys_setsockopt /* 105 */
.quad sys_listen
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 110 */
.quad sys_sigsuspend
.quad osf_sigstack
.quad sys_recvmsg
.quad sys_sendmsg
.quad alpha_ni_syscall /* 115 */
.quad osf_gettimeofday
.quad osf_getrusage
.quad sys_getsockopt
.quad alpha_ni_syscall
#ifdef CONFIG_OSF4_COMPAT
.quad osf_readv /* 120 */
.quad osf_writev
#else
.quad sys_readv /* 120 */
.quad sys_writev
#endif
.quad osf_settimeofday
.quad sys_fchown
.quad sys_fchmod
.quad sys_recvfrom /* 125 */
.quad sys_setreuid
.quad sys_setregid
.quad sys_rename
.quad sys_truncate
.quad sys_ftruncate /* 130 */
.quad sys_flock
.quad sys_setgid
.quad sys_sendto
.quad sys_shutdown
.quad sys_socketpair /* 135 */
.quad sys_mkdir
.quad sys_rmdir
.quad osf_utimes
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 140 */
.quad sys_getpeername
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad sys_getrlimit
.quad sys_setrlimit /* 145 */
.quad alpha_ni_syscall
.quad sys_setsid
.quad sys_quotactl
.quad alpha_ni_syscall
.quad sys_getsockname /* 150 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 155 */
.quad osf_sigaction
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad osf_getdirentries
.quad osf_statfs /* 160 */
.quad osf_fstatfs
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad osf_getdomainname /* 165 */
.quad sys_setdomainname
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 170 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 175 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 180 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 185 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 190 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 195 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad osf_swapon
.quad sys_msgctl /* 200 */
.quad sys_msgget
.quad sys_msgrcv
.quad sys_msgsnd
.quad sys_semctl
.quad sys_semget /* 205 */
.quad sys_semop
.quad osf_utsname
.quad sys_lchown
.quad osf_shmat
.quad sys_shmctl /* 210 */
.quad sys_shmdt
.quad sys_shmget
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 215 */
.quad alpha_ni_syscall
.quad sys_msync
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 220 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 225 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 230 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad sys_getpgid
.quad sys_getsid
.quad sys_sigaltstack /* 235 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 240 */
.quad osf_sysinfo
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad osf_proplist_syscall
.quad alpha_ni_syscall /* 245 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 250 */
.quad osf_usleep_thread
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad sys_sysfs
.quad alpha_ni_syscall /* 255 */
.quad osf_getsysinfo
.quad osf_setsysinfo
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 260 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 265 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 270 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 275 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 280 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 285 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 290 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 295 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
/* linux-specific system calls start at 300 */
.quad sys_bdflush /* 300 */
.quad sys_sethae
.quad sys_mount
.quad sys_old_adjtimex
.quad sys_swapoff
.quad sys_getdents /* 305 */
.quad alpha_create_module
.quad sys_init_module
.quad sys_delete_module
.quad sys_get_kernel_syms
.quad sys_syslog /* 310 */
.quad sys_reboot
.quad sys_clone
.quad sys_uselib
.quad sys_mlock
.quad sys_munlock /* 315 */
.quad sys_mlockall
.quad sys_munlockall
.quad sys_sysinfo
.quad sys_sysctl
.quad sys_ni_syscall /* 320 */
.quad sys_oldumount
.quad sys_swapon
.quad sys_times
.quad sys_personality
.quad sys_setfsuid /* 325 */
.quad sys_setfsgid
.quad sys_ustat
.quad sys_statfs
.quad sys_fstatfs
.quad sys_sched_setparam /* 330 */
.quad sys_sched_getparam
.quad sys_sched_setscheduler
.quad sys_sched_getscheduler
.quad sys_sched_yield
.quad sys_sched_get_priority_max /* 335 */
.quad sys_sched_get_priority_min
.quad sys_sched_rr_get_interval
.quad sys_ni_syscall /* sys_afs_syscall */
.quad sys_newuname
.quad sys_nanosleep /* 340 */
.quad sys_mremap
.quad sys_nfsservctl
.quad sys_setresuid
.quad sys_getresuid
.quad sys_pciconfig_read /* 345 */
.quad sys_pciconfig_write
.quad sys_query_module
.quad sys_prctl
.quad sys_pread64
.quad sys_pwrite64 /* 350 */
.quad sys_rt_sigreturn
.quad sys_rt_sigaction
.quad sys_rt_sigprocmask
.quad sys_rt_sigpending
.quad sys_rt_sigtimedwait /* 355 */
.quad sys_rt_sigqueueinfo
.quad sys_rt_sigsuspend
.quad sys_select
.quad sys_gettimeofday
.quad sys_settimeofday /* 360 */
.quad sys_getitimer
.quad sys_setitimer
.quad sys_utimes
.quad sys_getrusage
.quad sys_wait4 /* 365 */
.quad sys_adjtimex
.quad sys_getcwd
.quad sys_capget
.quad sys_capset
.quad sys_sendfile /* 370 */
.quad sys_setresgid
.quad sys_getresgid
.quad sys_ni_syscall /* sys_dipc */
.quad sys_pivot_root
.quad sys_mincore /* 375 */
.quad sys_pciconfig_iobase
.quad sys_getdents64
.quad sys_gettid
.quad sys_readahead
.quad sys_ni_syscall /* 380, sys_security */
.quad sys_tkill
.quad sys_setxattr
.quad sys_lsetxattr
.quad sys_fsetxattr
.quad sys_getxattr
.quad sys_lgetxattr
.quad sys_fgetxattr
.quad sys_listxattr
.quad sys_llistxattr
.quad sys_flistxattr /* 390 */
.quad sys_removexattr
.quad sys_lremovexattr
.quad sys_fremovexattr
.quad sys_futex
.quad sys_sched_setaffinity
.quad sys_sched_getaffinity
.quad sys_ni_syscall /* 397, tux */
.quad sys_io_setup
.quad sys_io_destroy
.quad sys_io_getevents /* 400 */
.quad sys_io_submit
.quad sys_io_cancel
.quad sys_ni_syscall /* 403, sys_alloc_hugepages */
.quad sys_ni_syscall /* 404, sys_free_hugepages */
.quad sys_exit_group
arch/alpha/kernel/osf_sys.c
View file @ 994b3fb0
......@@ -44,8 +44,9 @@
#include <asm/processor.h>
extern int do_pipe(int *);
extern asmlinkage unsigned long sys_brk(unsigned long);
extern int sys_getpriority(int, int);
extern asmlinkage unsigned long sys_create_module(char *, unsigned long);
/*
* Brk needs to return an error. Still support Linux's brk(0) query idiom,
......@@ -53,7 +54,8 @@ extern asmlinkage unsigned long sys_brk(unsigned long);
* identical to OSF as we don't return 0 on success, but doing otherwise
* would require changes to libc. Hopefully this is good enough.
*/
asmlinkage unsigned long osf_brk(unsigned long brk)
asmlinkage unsigned long
osf_brk(unsigned long brk)
{
unsigned long retval = sys_brk(brk);
if (brk && brk != retval)
......@@ -64,8 +66,8 @@ asmlinkage unsigned long osf_brk(unsigned long brk)
/*
* This is pure guess-work..
*/
asmlinkage int osf_set_program_attributes(
unsigned long text_start, unsigned long text_len,
asmlinkage int
osf_set_program_attributes(unsigned long text_start, unsigned long text_len,
unsigned long bss_start, unsigned long bss_len)
{
struct mm_struct *mm;
......@@ -106,7 +108,8 @@ struct osf_dirent_callback {
int error;
};
static int osf_filldir(void *__buf, const char *name, int namlen, loff_t offset,
static int
osf_filldir(void *__buf, const char *name, int namlen, loff_t offset,
ino_t ino, unsigned int d_type)
{
struct osf_dirent *dirent;
......@@ -134,7 +137,8 @@ static int osf_filldir(void *__buf, const char *name, int namlen, loff_t offset,
return 0;
}
asmlinkage int osf_getdirentries(unsigned int fd, struct osf_dirent *dirent,
asmlinkage int
osf_getdirentries(unsigned int fd, struct osf_dirent *dirent,
unsigned int count, long *basep)
{
int error;
......@@ -159,9 +163,9 @@ asmlinkage int osf_getdirentries(unsigned int fd, struct osf_dirent *dirent,
if (count != buf.count)
error = count - buf.count;
out_putf:
out_putf:
fput(file);
out:
out:
return error;
}
......@@ -172,8 +176,9 @@ asmlinkage int osf_getdirentries(unsigned int fd, struct osf_dirent *dirent,
* Alpha syscall convention has no problem returning negative
* values:
*/
asmlinkage int osf_getpriority(int which, int who, int a2, int a3, int a4,
int a5, struct pt_regs regs)
asmlinkage int
osf_getpriority(int which, int who,
int a2, int a3, int a4, int a5, struct pt_regs regs)
{
extern int sys_getpriority(int, int);
int prio;
......@@ -194,24 +199,24 @@ asmlinkage int osf_getpriority(int which, int who, int a2, int a3, int a4,
/*
* No need to acquire the kernel lock, we're local..
*/
asmlinkage unsigned long sys_getxuid(int a0, int a1, int a2, int a3, int a4,
int a5, struct pt_regs regs)
asmlinkage unsigned long
sys_getxuid(int a0, int a1, int a2, int a3, int a4, int a5, struct pt_regs regs)
{
struct task_struct * tsk = current;
(&regs)->r20 = tsk->euid;
return tsk->uid;
}
asmlinkage unsigned long sys_getxgid(int a0, int a1, int a2, int a3, int a4,
int a5, struct pt_regs regs)
asmlinkage unsigned long
sys_getxgid(int a0, int a1, int a2, int a3, int a4, int a5, struct pt_regs regs)
{
struct task_struct * tsk = current;
(&regs)->r20 = tsk->egid;
return tsk->gid;
}
asmlinkage unsigned long sys_getxpid(int a0, int a1, int a2, int a3, int a4,
int a5, struct pt_regs regs)
asmlinkage unsigned long
sys_getxpid(int a0, int a1, int a2, int a3, int a4, int a5, struct pt_regs regs)
{
struct task_struct *tsk = current;
......@@ -226,9 +231,9 @@ asmlinkage unsigned long sys_getxpid(int a0, int a1, int a2, int a3, int a4,
return tsk->tgid;
}
asmlinkage unsigned long osf_mmap(unsigned long addr, unsigned long len,
unsigned long prot, unsigned long flags, unsigned long fd,
unsigned long off)
asmlinkage unsigned long
osf_mmap(unsigned long addr, unsigned long len, unsigned long prot,
unsigned long flags, unsigned long fd, unsigned long off)
{
struct file *file = NULL;
unsigned long ret = -EBADF;
......@@ -249,7 +254,7 @@ asmlinkage unsigned long osf_mmap(unsigned long addr, unsigned long len,
up_write(&current->mm->mmap_sem);
if (file)
fput(file);
out:
out:
return ret;
}
......@@ -271,7 +276,9 @@ struct osf_statfs {
__kernel_fsid_t f_fsid;
} *osf_stat;
static int linux_to_osf_statfs(struct statfs *linux_stat, struct osf_statfs *osf_stat, unsigned long bufsiz)
static int
linux_to_osf_statfs(struct statfs *linux_stat, struct osf_statfs *osf_stat,
unsigned long bufsiz)
{
struct osf_statfs tmp_stat;
......@@ -291,7 +298,9 @@ static int linux_to_osf_statfs(struct statfs *linux_stat, struct osf_statfs *osf
return copy_to_user(osf_stat, &tmp_stat, bufsiz) ? -EFAULT : 0;
}
static int do_osf_statfs(struct dentry * dentry, struct osf_statfs *buffer, unsigned long bufsiz)
static int
do_osf_statfs(struct dentry * dentry, struct osf_statfs *buffer,
unsigned long bufsiz)
{
struct statfs linux_stat;
int error = vfs_statfs(dentry->d_inode->i_sb, &linux_stat);
......@@ -300,7 +309,8 @@ static int do_osf_statfs(struct dentry * dentry, struct osf_statfs *buffer, unsi
return error;
}
asmlinkage int osf_statfs(char *path, struct osf_statfs *buffer, unsigned long bufsiz)
asmlinkage int
osf_statfs(char *path, struct osf_statfs *buffer, unsigned long bufsiz)
{
struct nameidata nd;
int retval;
......@@ -313,7 +323,8 @@ asmlinkage int osf_statfs(char *path, struct osf_statfs *buffer, unsigned long b
return retval;
}
asmlinkage int osf_fstatfs(unsigned long fd, struct osf_statfs *buffer, unsigned long bufsiz)
asmlinkage int
osf_fstatfs(unsigned long fd, struct osf_statfs *buffer, unsigned long bufsiz)
{
struct file *file;
int retval;
......@@ -342,10 +353,9 @@ struct cdfs_args {
char *devname;
int flags;
uid_t exroot;
/*
* This has lots more here, which Linux handles with the option block
* but I'm too lazy to do the translation into ASCII.
*/
/* This has lots more here, which Linux handles with the option block
but I'm too lazy to do the translation into ASCII. */
};
struct procfs_args {
......@@ -362,7 +372,8 @@ struct procfs_args {
* Just how long ago was it written? OTOH our UFS driver may be still
* unhappy with OSF UFS. [CHECKME]
*/
static int osf_ufs_mount(char *dirname, struct ufs_args *args, int flags)
static int
osf_ufs_mount(char *dirname, struct ufs_args *args, int flags)
{
int retval;
struct cdfs_args tmp;
......@@ -377,11 +388,12 @@ static int osf_ufs_mount(char *dirname, struct ufs_args *args, int flags)
goto out;
retval = do_mount(devname, dirname, "ext2", flags, NULL);
putname(devname);
out:
out:
return retval;
}
static int osf_cdfs_mount(char *dirname, struct cdfs_args *args, int flags)
static int
osf_cdfs_mount(char *dirname, struct cdfs_args *args, int flags)
{
int retval;
struct cdfs_args tmp;
......@@ -396,11 +408,12 @@ static int osf_cdfs_mount(char *dirname, struct cdfs_args *args, int flags)
goto out;
retval = do_mount(devname, dirname, "iso9660", flags, NULL);
putname(devname);
out:
out:
return retval;
}
static int osf_procfs_mount(char *dirname, struct procfs_args *args, int flags)
static int
osf_procfs_mount(char *dirname, struct procfs_args *args, int flags)
{
struct procfs_args tmp;
......@@ -410,7 +423,8 @@ static int osf_procfs_mount(char *dirname, struct procfs_args *args, int flags)
return do_mount("", dirname, "proc", flags, NULL);
}
asmlinkage int osf_mount(unsigned long typenr, char *path, int flag, void *data)
asmlinkage int
osf_mount(unsigned long typenr, char *path, int flag, void *data)
{
int retval = -EINVAL;
char *name;
......@@ -435,12 +449,13 @@ asmlinkage int osf_mount(unsigned long typenr, char *path, int flag, void *data)
printk("osf_mount(%ld, %x)\n", typenr, flag);
}
putname(name);
out:
out:
unlock_kernel();
return retval;
}
asmlinkage int osf_utsname(char *name)
asmlinkage int
osf_utsname(char *name)
{
int error;
......@@ -458,12 +473,13 @@ asmlinkage int osf_utsname(char *name)
goto out;
error = 0;
out:
out:
up_read(&uts_sem);
return error;
}
asmlinkage int osf_swapon(const char *path, int flags, int lowat, int hiwat)
asmlinkage int
osf_swapon(const char *path, int flags, int lowat, int hiwat)
{
int ret;
......@@ -474,35 +490,36 @@ asmlinkage int osf_swapon(const char *path, int flags, int lowat, int hiwat)
return ret;
}
asmlinkage unsigned long sys_getpagesize(void)
asmlinkage unsigned long
sys_getpagesize(void)
{
return PAGE_SIZE;
}
asmlinkage unsigned long sys_getdtablesize(void)
asmlinkage unsigned long
sys_getdtablesize(void)
{
return NR_OPEN;
}
asmlinkage int sys_pipe(int a0, int a1, int a2, int a3, int a4, int a5,
struct pt_regs regs)
asmlinkage int
sys_pipe(int a0, int a1, int a2, int a3, int a4, int a5, struct pt_regs regs)
{
int fd[2];
int error;
int fd[2], error;
error = do_pipe(fd);
if (error)
goto out;
(&regs)->r20 = fd[1];
if (!error) {
regs.r20 = fd[1];
error = fd[0];
out:
}
return error;
}
/*
* For compatibility with OSF/1 only. Use utsname(2) instead.
*/
asmlinkage int osf_getdomainname(char *name, int namelen)
asmlinkage int
osf_getdomainname(char *name, int namelen)
{
unsigned len;
int i, error;
......@@ -522,12 +539,12 @@ asmlinkage int osf_getdomainname(char *name, int namelen)
break;
}
up_read(&uts_sem);
out:
out:
return error;
}
asmlinkage long osf_shmat(int shmid, void *shmaddr, int shmflg)
asmlinkage long
osf_shmat(int shmid, void *shmaddr, int shmflg)
{
unsigned long raddr;
long err;
......@@ -541,7 +558,7 @@ asmlinkage long osf_shmat(int shmid, void *shmaddr, int shmflg)
* non-negative longs!
*/
err = raddr;
out:
out:
unlock_kernel();
return err;
}
......@@ -612,7 +629,8 @@ enum pl_code {
PL_DEL = 5, PL_FDEL = 6
};
asmlinkage long osf_proplist_syscall(enum pl_code code, union pl_args *args)
asmlinkage long
osf_proplist_syscall(enum pl_code code, union pl_args *args)
{
long error;
int *min_buf_size_ptr;
......@@ -655,7 +673,8 @@ asmlinkage long osf_proplist_syscall(enum pl_code code, union pl_args *args)
return error;
}
asmlinkage int osf_sigstack(struct sigstack *uss, struct sigstack *uoss)
asmlinkage int
osf_sigstack(struct sigstack *uss, struct sigstack *uoss)
{
unsigned long usp = rdusp();
unsigned long oss_sp = current->sas_ss_sp + current->sas_ss_size;
......@@ -691,7 +710,7 @@ asmlinkage int osf_sigstack(struct sigstack *uss, struct sigstack *uoss)
}
error = 0;
out:
out:
return error;
}
......@@ -702,32 +721,28 @@ asmlinkage int osf_sigstack(struct sigstack *uss, struct sigstack *uoss)
* create_module() because it's one of the few system calls
* that return kernel addresses (which are negative).
*/
asmlinkage unsigned long alpha_create_module(char *module_name, unsigned long size,
int a3, int a4, int a5, int a6,
struct pt_regs regs)
asmlinkage unsigned long
alpha_create_module(char *module_name, unsigned long size,
int a3, int a4, int a5, int a6, struct pt_regs regs)
{
asmlinkage unsigned long sys_create_module(char *, unsigned long);
long retval;
lock_kernel();
retval = sys_create_module(module_name, size);
/*
* we get either a module address or an error number,
* and we know the error number is a small negative
* number, while the address is always negative but
* much larger.
*/
if (retval + 1000 > 0)
goto out;
/* tell entry.S:syscall_error that this is NOT an error: */
/* We get either a module address or an error number, and we know
the error number is a small negative number, while the address
is always negative but much larger. */
if (retval + 1000 < 0)
regs.r0 = 0;
out:
unlock_kernel();
return retval;
}
asmlinkage long osf_sysinfo(int command, char *buf, long count)
asmlinkage long
osf_sysinfo(int command, char *buf, long count)
{
static char * sysinfo_table[] = {
system_utsname.sysname,
......@@ -761,12 +776,12 @@ asmlinkage long osf_sysinfo(int command, char *buf, long count)
else
err = 0;
up_read(&uts_sem);
out:
out:
return err;
}
asmlinkage unsigned long osf_getsysinfo(unsigned long op, void *buffer,
unsigned long nbytes,
asmlinkage unsigned long
osf_getsysinfo(unsigned long op, void *buffer, unsigned long nbytes,
int *start, void *arg)
{
unsigned long w;
......@@ -823,8 +838,8 @@ asmlinkage unsigned long osf_getsysinfo(unsigned long op, void *buffer,
return -EOPNOTSUPP;
}
asmlinkage unsigned long osf_setsysinfo(unsigned long op, void *buffer,
unsigned long nbytes,
asmlinkage unsigned long
osf_setsysinfo(unsigned long op, void *buffer, unsigned long nbytes,
int *start, void *arg)
{
switch (op) {
......@@ -925,21 +940,24 @@ struct itimerval32
struct timeval32 it_value;
};
static inline long get_tv32(struct timeval *o, struct timeval32 *i)
static inline long
get_tv32(struct timeval *o, struct timeval32 *i)
{
return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
(__get_user(o->tv_sec, &i->tv_sec) |
__get_user(o->tv_usec, &i->tv_usec)));
}
static inline long put_tv32(struct timeval32 *o, struct timeval *i)
static inline long
put_tv32(struct timeval32 *o, struct timeval *i)
{
return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
(__put_user(i->tv_sec, &o->tv_sec) |
__put_user(i->tv_usec, &o->tv_usec)));
}
static inline long get_it32(struct itimerval *o, struct itimerval32 *i)
static inline long
get_it32(struct itimerval *o, struct itimerval32 *i)
{
return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
(__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) |
......@@ -948,7 +966,8 @@ static inline long get_it32(struct itimerval *o, struct itimerval32 *i)
__get_user(o->it_value.tv_usec, &i->it_value.tv_usec)));
}
static inline long put_it32(struct itimerval32 *o, struct itimerval *i)
static inline long
put_it32(struct itimerval32 *o, struct itimerval *i)
{
return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
(__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) |
......@@ -964,7 +983,8 @@ jiffies_to_timeval32(unsigned long jiffies, struct timeval32 *value)
value->tv_sec = jiffies / HZ;
}
asmlinkage int osf_gettimeofday(struct timeval32 *tv, struct timezone *tz)
asmlinkage int
osf_gettimeofday(struct timeval32 *tv, struct timezone *tz)
{
if (tv) {
struct timeval ktv;
......@@ -979,7 +999,8 @@ asmlinkage int osf_gettimeofday(struct timeval32 *tv, struct timezone *tz)
return 0;
}
asmlinkage int osf_settimeofday(struct timeval32 *tv, struct timezone *tz)
asmlinkage int
osf_settimeofday(struct timeval32 *tv, struct timezone *tz)
{
struct timeval ktv;
struct timezone ktz;
......@@ -996,7 +1017,8 @@ asmlinkage int osf_settimeofday(struct timeval32 *tv, struct timezone *tz)
return do_sys_settimeofday(tv ? &ktv : NULL, tz ? &ktz : NULL);
}
asmlinkage int osf_getitimer(int which, struct itimerval32 *it)
asmlinkage int
osf_getitimer(int which, struct itimerval32 *it)
{
struct itimerval kit;
int error;
......@@ -1008,8 +1030,8 @@ asmlinkage int osf_getitimer(int which, struct itimerval32 *it)
return error;
}
asmlinkage int osf_setitimer(int which, struct itimerval32 *in,
struct itimerval32 *out)
asmlinkage int
osf_setitimer(int which, struct itimerval32 *in, struct itimerval32 *out)
{
struct itimerval kin, kout;
int error;
......@@ -1031,7 +1053,8 @@ asmlinkage int osf_setitimer(int which, struct itimerval32 *in,
}
asmlinkage int osf_utimes(const char *filename, struct timeval32 *tvs)
asmlinkage int
osf_utimes(const char *filename, struct timeval32 *tvs)
{
char *kfilename;
struct timeval ktvs[2];
......@@ -1136,9 +1159,9 @@ osf_select(int n, fd_set *inp, fd_set *outp, fd_set *exp,
set_fd_set(n, outp->fds_bits, fds.res_out);
set_fd_set(n, exp->fds_bits, fds.res_ex);
out:
out:
kfree(bits);
out_nofds:
out_nofds:
return ret;
}
......@@ -1161,7 +1184,8 @@ struct rusage32 {
long ru_nivcsw; /* involuntary " */
};
asmlinkage int osf_getrusage(int who, struct rusage32 *ru)
asmlinkage int
osf_getrusage(int who, struct rusage32 *ru)
{
struct rusage32 r;
......@@ -1198,8 +1222,8 @@ asmlinkage int osf_getrusage(int who, struct rusage32 *ru)
return copy_to_user(ru, &r, sizeof(r)) ? -EFAULT : 0;
}
asmlinkage int osf_wait4(pid_t pid, int *ustatus, int options,
struct rusage32 *ur)
asmlinkage int
osf_wait4(pid_t pid, int *ustatus, int options, struct rusage32 *ur)
{
if (!ur) {
return sys_wait4(pid, ustatus, options, NULL);
......@@ -1245,7 +1269,8 @@ asmlinkage int osf_wait4(pid_t pid, int *ustatus, int options,
* seems to be a timeval pointer, and I suspect the second
* one is the time remaining.. Ho humm.. No documentation.
*/
asmlinkage int osf_usleep_thread(struct timeval32 *sleep, struct timeval32 *remain)
asmlinkage int
osf_usleep_thread(struct timeval32 *sleep, struct timeval32 *remain)
{
struct timeval tmp;
unsigned long ticks;
......@@ -1268,7 +1293,7 @@ asmlinkage int osf_usleep_thread(struct timeval32 *sleep, struct timeval32 *rema
}
return 0;
fault:
fault:
return -EFAULT;
}
......@@ -1302,7 +1327,8 @@ struct timex32 {
int :32; int :32; int :32; int :32;
};
asmlinkage int sys_old_adjtimex(struct timex32 *txc_p)
asmlinkage int
sys_old_adjtimex(struct timex32 *txc_p)
{
struct timex txc;
int ret;
......
arch/alpha/kernel/process.c
View file @ 994b3fb0
......@@ -191,26 +191,13 @@ machine_power_off(void)
common_shutdown(LINUX_REBOOT_CMD_POWER_OFF, NULL);
}
/* Used by sysrq-p, among others. I don't believe r9-r15 are ever
saved in the context it's used. */
void
show_regs(struct pt_regs * regs)
show_regs(struct pt_regs *regs)
{
printk("\n");
printk("Pid: %d, comm: %20s\n", current->pid, current->comm);
printk("ps: %04lx pc: [<%016lx>] CPU %d %s\n",
regs->ps, regs->pc, smp_processor_id(), print_tainted());
printk("rp: [<%016lx>] sp: %p\n", regs->r26, regs+1);
printk(" r0: %016lx r1: %016lx r2: %016lx r3: %016lx\n",
regs->r0, regs->r1, regs->r2, regs->r3);
printk(" r4: %016lx r5: %016lx r6: %016lx r7: %016lx\n",
regs->r4, regs->r5, regs->r6, regs->r7);
printk(" r8: %016lx r16: %016lx r17: %016lx r18: %016lx\n",
regs->r8, regs->r16, regs->r17, regs->r18);
printk("r19: %016lx r20: %016lx r21: %016lx r22: %016lx\n",
regs->r19, regs->r20, regs->r21, regs->r22);
printk("r23: %016lx r24: %016lx r25: %016lx r26: %016lx\n",
regs->r23, regs->r24, regs->r25, regs->r26);
printk("r27: %016lx r28: %016lx r29: %016lx hae: %016lx\n",
regs->r27, regs->r28, regs->gp, regs->hae);
dik_show_regs(regs, 0);
}
/*
......
arch/alpha/kernel/setup.c
View file @ 994b3fb0
......@@ -37,6 +37,11 @@
#include <linux/blk.h>
#endif
#ifdef CONFIG_MAGIC_SYSRQ
#include <linux/sysrq.h>
#include <linux/reboot.h>
#endif
#include <linux/notifier.h>
extern struct notifier_block *panic_notifier_list;
static int alpha_panic_event(struct notifier_block *, unsigned long, void *);
......@@ -539,6 +544,15 @@ setup_arch(char **cmdline_p)
register_srm_console();
}
#ifdef CONFIG_MAGIC_SYSRQ
/* If we're using SRM, make sysrq-b halt back to the prom,
not auto-reboot. */
if (alpha_using_srm) {
struct sysrq_key_op *op = __sysrq_get_key_op('b');
op->handler = (void *) machine_halt;
}
#endif
/*
* Indentify and reconfigure for the current system.
*/
......
arch/alpha/kernel/systbls.S 0 → 100644
View file @ 994b3fb0
/*
* arch/alpha/kernel/systbls.S
*
* The system call table.
*/
#include <asm/unistd.h>
.data
.align 3
.globl sys_call_table
sys_call_table:
.quad alpha_ni_syscall /* 0 */
.quad sys_exit
.quad sys_fork
.quad sys_read
.quad sys_write
.quad alpha_ni_syscall /* 5 */
.quad sys_close
.quad osf_wait4
.quad alpha_ni_syscall
.quad sys_link
.quad sys_unlink /* 10 */
.quad alpha_ni_syscall
.quad sys_chdir
.quad sys_fchdir
.quad sys_mknod
.quad sys_chmod /* 15 */
.quad sys_chown
.quad osf_brk
.quad alpha_ni_syscall
.quad sys_lseek
.quad sys_getxpid /* 20 */
.quad osf_mount
.quad sys_umount
.quad sys_setuid
.quad sys_getxuid
.quad alpha_ni_syscall /* 25 */
.quad sys_ptrace
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 30 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad sys_access
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 35 */
.quad sys_sync
.quad sys_kill
.quad alpha_ni_syscall
.quad sys_setpgid
.quad alpha_ni_syscall /* 40 */
.quad sys_dup
.quad sys_pipe
.quad osf_set_program_attributes
.quad alpha_ni_syscall
.quad sys_open /* 45 */
.quad alpha_ni_syscall
.quad sys_getxgid
.quad osf_sigprocmask
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 50 */
.quad sys_acct
.quad sys_sigpending
.quad alpha_ni_syscall
.quad sys_ioctl
.quad alpha_ni_syscall /* 55 */
.quad alpha_ni_syscall
.quad sys_symlink
.quad sys_readlink
.quad sys_execve
.quad sys_umask /* 60 */
.quad sys_chroot
.quad alpha_ni_syscall
.quad sys_getpgrp
.quad sys_getpagesize
.quad alpha_ni_syscall /* 65 */
.quad sys_vfork
.quad sys_newstat
.quad sys_newlstat
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 70 */
.quad osf_mmap
.quad alpha_ni_syscall
.quad sys_munmap
.quad sys_mprotect
.quad sys_madvise /* 75 */
.quad sys_vhangup
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad sys_getgroups
/* map BSD's setpgrp to sys_setpgid for binary compatibility: */
.quad sys_setgroups /* 80 */
.quad alpha_ni_syscall
.quad sys_setpgid
.quad osf_setitimer
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 85 */
.quad osf_getitimer
.quad sys_gethostname
.quad sys_sethostname
.quad sys_getdtablesize
.quad sys_dup2 /* 90 */
.quad sys_newfstat
.quad sys_fcntl
.quad osf_select
.quad sys_poll
.quad sys_fsync /* 95 */
.quad sys_setpriority
.quad sys_socket
.quad sys_connect
.quad sys_accept
.quad osf_getpriority /* 100 */
.quad sys_send
.quad sys_recv
.quad sys_sigreturn
.quad sys_bind
.quad sys_setsockopt /* 105 */
.quad sys_listen
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 110 */
.quad sys_sigsuspend
.quad osf_sigstack
.quad sys_recvmsg
.quad sys_sendmsg
.quad alpha_ni_syscall /* 115 */
.quad osf_gettimeofday
.quad osf_getrusage
.quad sys_getsockopt
.quad alpha_ni_syscall
#ifdef CONFIG_OSF4_COMPAT
.quad osf_readv /* 120 */
.quad osf_writev
#else
.quad sys_readv /* 120 */
.quad sys_writev
#endif
.quad osf_settimeofday
.quad sys_fchown
.quad sys_fchmod
.quad sys_recvfrom /* 125 */
.quad sys_setreuid
.quad sys_setregid
.quad sys_rename
.quad sys_truncate
.quad sys_ftruncate /* 130 */
.quad sys_flock
.quad sys_setgid
.quad sys_sendto
.quad sys_shutdown
.quad sys_socketpair /* 135 */
.quad sys_mkdir
.quad sys_rmdir
.quad osf_utimes
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 140 */
.quad sys_getpeername
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad sys_getrlimit
.quad sys_setrlimit /* 145 */
.quad alpha_ni_syscall
.quad sys_setsid
.quad sys_quotactl
.quad alpha_ni_syscall
.quad sys_getsockname /* 150 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 155 */
.quad osf_sigaction
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad osf_getdirentries
.quad osf_statfs /* 160 */
.quad osf_fstatfs
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad osf_getdomainname /* 165 */
.quad sys_setdomainname
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 170 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 175 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 180 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 185 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 190 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 195 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad osf_swapon
.quad sys_msgctl /* 200 */
.quad sys_msgget
.quad sys_msgrcv
.quad sys_msgsnd
.quad sys_semctl
.quad sys_semget /* 205 */
.quad sys_semop
.quad osf_utsname
.quad sys_lchown
.quad osf_shmat
.quad sys_shmctl /* 210 */
.quad sys_shmdt
.quad sys_shmget
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 215 */
.quad alpha_ni_syscall
.quad sys_msync
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 220 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 225 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 230 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad sys_getpgid
.quad sys_getsid
.quad sys_sigaltstack /* 235 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 240 */
.quad osf_sysinfo
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad osf_proplist_syscall
.quad alpha_ni_syscall /* 245 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 250 */
.quad osf_usleep_thread
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad sys_sysfs
.quad alpha_ni_syscall /* 255 */
.quad osf_getsysinfo
.quad osf_setsysinfo
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 260 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 265 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 270 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 275 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 280 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 285 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 290 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall /* 295 */
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
.quad alpha_ni_syscall
/* linux-specific system calls start at 300 */
.quad sys_bdflush /* 300 */
.quad sys_sethae
.quad sys_mount
.quad sys_old_adjtimex
.quad sys_swapoff
.quad sys_getdents /* 305 */
.quad alpha_create_module
.quad sys_init_module
.quad sys_delete_module
.quad sys_get_kernel_syms
.quad sys_syslog /* 310 */
.quad sys_reboot
.quad sys_clone
.quad sys_uselib
.quad sys_mlock
.quad sys_munlock /* 315 */
.quad sys_mlockall
.quad sys_munlockall
.quad sys_sysinfo
.quad sys_sysctl
.quad sys_ni_syscall /* 320 */
.quad sys_oldumount
.quad sys_swapon
.quad sys_times
.quad sys_personality
.quad sys_setfsuid /* 325 */
.quad sys_setfsgid
.quad sys_ustat
.quad sys_statfs
.quad sys_fstatfs
.quad sys_sched_setparam /* 330 */
.quad sys_sched_getparam
.quad sys_sched_setscheduler
.quad sys_sched_getscheduler
.quad sys_sched_yield
.quad sys_sched_get_priority_max /* 335 */
.quad sys_sched_get_priority_min
.quad sys_sched_rr_get_interval
.quad sys_ni_syscall /* sys_afs_syscall */
.quad sys_newuname
.quad sys_nanosleep /* 340 */
.quad sys_mremap
.quad sys_nfsservctl
.quad sys_setresuid
.quad sys_getresuid
.quad sys_pciconfig_read /* 345 */
.quad sys_pciconfig_write
.quad sys_query_module
.quad sys_prctl
.quad sys_pread64
.quad sys_pwrite64 /* 350 */
.quad sys_rt_sigreturn
.quad sys_rt_sigaction
.quad sys_rt_sigprocmask
.quad sys_rt_sigpending
.quad sys_rt_sigtimedwait /* 355 */
.quad sys_rt_sigqueueinfo
.quad sys_rt_sigsuspend
.quad sys_select
.quad sys_gettimeofday
.quad sys_settimeofday /* 360 */
.quad sys_getitimer
.quad sys_setitimer
.quad sys_utimes
.quad sys_getrusage
.quad sys_wait4 /* 365 */
.quad sys_adjtimex
.quad sys_getcwd
.quad sys_capget
.quad sys_capset
.quad sys_sendfile /* 370 */
.quad sys_setresgid
.quad sys_getresgid
.quad sys_ni_syscall /* sys_dipc */
.quad sys_pivot_root
.quad sys_mincore /* 375 */
.quad sys_pciconfig_iobase
.quad sys_getdents64
.quad sys_gettid
.quad sys_readahead
.quad sys_ni_syscall /* 380, sys_security */
.quad sys_tkill
.quad sys_setxattr
.quad sys_lsetxattr
.quad sys_fsetxattr
.quad sys_getxattr /* 385 */
.quad sys_lgetxattr
.quad sys_fgetxattr
.quad sys_listxattr
.quad sys_llistxattr
.quad sys_flistxattr /* 390 */
.quad sys_removexattr
.quad sys_lremovexattr
.quad sys_fremovexattr
.quad sys_futex
.quad sys_sched_setaffinity /* 395 */
.quad sys_sched_getaffinity
.quad sys_ni_syscall /* 397, tux */
.quad sys_io_setup
.quad sys_io_destroy
.quad sys_io_getevents /* 400 */
.quad sys_io_submit
.quad sys_io_cancel
.quad sys_ni_syscall /* 403, sys_alloc_hugepages */
.quad sys_ni_syscall /* 404, sys_free_hugepages */
.quad sys_exit_group
.size sys_call_table, . - sys_call_table
.type sys_call_table, @object
/* Remember to update everything, kids. */
.ifne (. - sys_call_table) - (NR_SYSCALLS * 8)
.err
.endif
arch/alpha/lib/Makefile
View file @ 994b3fb0
......@@ -51,14 +51,16 @@ obj-$(CONFIG_SMP) += dec_and_lock.o
include $(TOPDIR)/Rules.make
__divqu.o: $(ev6)divide.S
$(CC) $(AFLAGS) -DDIV -c -o __divqu.o $(ev6)divide.S
$(obj)/__divqu.o: $(obj)/$(ev6)divide.S
$(CC) $(AFLAGS) -DDIV -c -o $(obj)/__divqu.o $(obj)/$(ev6)divide.S
__remqu.o: $(ev6)divide.S
$(CC) $(AFLAGS) -DREM -c -o __remqu.o $(ev6)divide.S
$(obj)/__remqu.o: $(obj)/$(ev6)divide.S
$(CC) $(AFLAGS) -DREM -c -o $(obj)/__remqu.o $(obj)/$(ev6)divide.S
__divlu.o: $(ev6)divide.S
$(CC) $(AFLAGS) -DDIV -DINTSIZE -c -o __divlu.o $(ev6)divide.S
$(obj)/__divlu.o: $(obj)/$(ev6)divide.S
$(CC) $(AFLAGS) -DDIV -DINTSIZE \
-c -o $(obj)/__divlu.o $(obj)/$(ev6)divide.S
__remlu.o: $(ev6)divide.S
$(CC) $(AFLAGS) -DREM -DINTSIZE -c -o __remlu.o $(ev6)divide.S
$(obj)/__remlu.o: $(obj)/$(ev6)divide.S
$(CC) $(AFLAGS) -DREM -DINTSIZE \
-c -o $(obj)/__remlu.o $(obj)/$(ev6)divide.S
arch/alpha/lib/stxncpy.S
View file @ 994b3fb0
......@@ -278,7 +278,7 @@ $u_eoc:
extqh t2, a1, t0 # e0 : extract low bits for last word
or t1, t0, t1 # e1 :
1: cmpbge zero, t1, t7
1: cmpbge zero, t1, t8
mov t1, t0
$u_eocfin: # end-of-count, final word
......
arch/alpha/mm/fault.c
View file @ 994b3fb0
......@@ -125,11 +125,10 @@ do_page_fault(unsigned long address, unsigned long mmcsr,
goto bad_area;
if (expand_stack(vma, address))
goto bad_area;
/*
* Ok, we have a good vm_area for this memory access, so
* we can handle it..
*/
good_area:
/* Ok, we have a good vm_area for this memory access, so
we can handle it. */
good_area:
if (cause < 0) {
if (!(vma->vm_flags & VM_EXEC))
goto bad_area;
......@@ -143,11 +142,9 @@ do_page_fault(unsigned long address, unsigned long mmcsr,
}
survive:
/*
* If for any reason at all we couldn't handle the fault,
* make sure we exit gracefully rather than endlessly redo
* the fault.
*/
/* If for any reason at all we couldn't handle the fault,
make sure we exit gracefully rather than endlessly redo
the fault. */
fault = handle_mm_fault(mm, vma, address, cause > 0);
up_read(&mm->mmap_sem);
......@@ -155,14 +152,11 @@ do_page_fault(unsigned long address, unsigned long mmcsr,
goto out_of_memory;
if (fault == 0)
goto do_sigbus;
return;
/*
* Something tried to access memory that isn't in our memory map..
* Fix it, but check if it's kernel or user first..
*/
bad_area:
/* Something tried to access memory that isn't in our memory map.
Fix it, but check if it's kernel or user first. */
bad_area:
up_read(&mm->mmap_sem);
if (user_mode(regs)) {
......@@ -170,7 +164,7 @@ do_page_fault(unsigned long address, unsigned long mmcsr,
return;
}
no_context:
no_context:
/* Are we prepared to handle this fault as an exception? */
if ((fixup = search_exception_table(regs->pc, regs->gp)) != 0) {
unsigned long newpc;
......@@ -183,20 +177,16 @@ do_page_fault(unsigned long address, unsigned long mmcsr,
return;
}
/*
* Oops. The kernel tried to access some bad page. We'll have to
* terminate things with extreme prejudice.
*/
/* Oops. The kernel tried to access some bad page. We'll have to
terminate things with extreme prejudice. */
printk(KERN_ALERT "Unable to handle kernel paging request at "
"virtual address %016lx\n", address);
die_if_kernel("Oops", regs, cause, (unsigned long*)regs - 16);
do_exit(SIGKILL);
/*
* We ran out of memory, or some other thing happened to us that made
* us unable to handle the page fault gracefully.
*/
out_of_memory:
/* We ran out of memory, or some other thing happened to us that
made us unable to handle the page fault gracefully. */
out_of_memory:
if (current->pid == 1) {
yield();
down_read(&mm->mmap_sem);
......@@ -208,18 +198,16 @@ do_page_fault(unsigned long address, unsigned long mmcsr,
goto no_context;
do_exit(SIGKILL);
do_sigbus:
/*
* Send a sigbus, regardless of whether we were in kernel
* or user mode.
*/
do_sigbus:
/* Send a sigbus, regardless of whether we were in kernel
or user mode. */
force_sig(SIGBUS, current);
if (!user_mode(regs))
goto no_context;
return;
#ifdef CONFIG_ALPHA_LARGE_VMALLOC
vmalloc_fault:
vmalloc_fault:
if (user_mode(regs)) {
force_sig(SIGSEGV, current);
return;
......
arch/alpha/vmlinux.lds.S
View file @ 994b3fb0
......@@ -58,10 +58,11 @@ SECTIONS
__initcall_end = .;
}
. = ALIGN(64);
.data.percpu ALIGN(64): {
__per_cpu_start = .;
.data.percpu : { *(.data.percpu) }
*(.data.percpu)
__per_cpu_end = .;
}
/* The initial task and kernel stack */
.data.init_thread ALIGN(2*8192) : {
......
drivers/ide/ide-disk.c
View file @ 994b3fb0
......@@ -1664,14 +1664,6 @@ static int idedisk_resume(struct device *dev, u32 level)
/* This is just a hook for the overall driver tree.
*/
static struct device_driver idedisk_devdrv = {
.bus = &ide_bus_type,
.name = "IDE disk driver",
.suspend = idedisk_suspend,
.resume = idedisk_resume,
};
static int idedisk_ioctl (ide_drive_t *drive, struct inode *inode,
struct file *file, unsigned int cmd, unsigned long arg)
{
......@@ -1717,12 +1709,6 @@ static void idedisk_setup (ide_drive_t *drive)
drive->doorlocking = 1;
}
}
{
sprintf(drive->disk->disk_dev.name, "ide-disk");
drive->disk->disk_dev.driver = &idedisk_devdrv;
drive->disk->disk_dev.driver_data = drive;
}
#if 1
(void) probe_lba_addressing(drive, 1);
#else
......@@ -1806,7 +1792,6 @@ static int idedisk_cleanup (ide_drive_t *drive)
{
struct gendisk *g = drive->disk;
device_unregister(&drive->disk->disk_dev);
if ((drive->id->cfs_enable_2 & 0x3000) && drive->wcache)
if (do_idedisk_flushcache(drive))
printk (KERN_INFO "%s: Write Cache FAILED Flushing!\n",
......@@ -1905,7 +1890,6 @@ static void __exit idedisk_exit (void)
static int idedisk_init (void)
{
ide_register_driver(&idedisk_driver);
driver_register(&idedisk_devdrv);
return 0;
}
......
drivers/ide/ide-probe.c
View file @ 994b3fb0
......@@ -998,15 +998,6 @@ static void init_gendisk (ide_hwif_t *hwif)
sprintf(disk->disk_name,"hd%c",'a'+hwif->index*MAX_DRIVES+unit);
disk->minor_shift = PARTN_BITS;
disk->fops = ide_fops;
snprintf(disk->disk_dev.bus_id,BUS_ID_SIZE,"%u.%u",
hwif->index,unit);
snprintf(disk->disk_dev.name,DEVICE_NAME_SIZE,
"%s","IDE Drive");
disk->disk_dev.parent = &hwif->gendev;
disk->disk_dev.bus = &ide_bus_type;
if (hwif->drives[unit].present)
device_register(&disk->disk_dev);
hwif->drives[unit].disk = disk;
}
......@@ -1020,6 +1011,20 @@ static void init_gendisk (ide_hwif_t *hwif)
if (hwif->drives[unit].present)
hwif->drives[unit].de = devfs_mk_dir(ide_devfs_handle, name, NULL);
}
for (unit = 0; unit < units; ++unit) {
ide_drive_t * drive = &hwif->drives[unit];
snprintf(drive->gendev.bus_id,BUS_ID_SIZE,"%u.%u",
hwif->index,unit);
snprintf(drive->gendev.name,DEVICE_NAME_SIZE,
"%s","IDE Drive");
drive->gendev.parent = &hwif->gendev;
drive->gendev.bus = &ide_bus_type;
if (drive->present)
device_register(&drive->gendev);
}
return;
err_kmalloc_gd:
......
drivers/ide/ide.c
View file @ 994b3fb0
......@@ -2463,6 +2463,7 @@ int ata_attach(ide_drive_t *drive)
if (driver->attach(drive) == 0) {
if (driver->owner)
__MOD_DEC_USE_COUNT(driver->owner);
drive->gendev.driver = &driver->gen_driver;
return 0;
}
spin_lock(&drivers_lock);
......@@ -3422,6 +3423,21 @@ int ide_unregister_subdriver (ide_drive_t *drive)
EXPORT_SYMBOL(ide_unregister_subdriver);
static int ide_drive_remove(struct device * dev)
{
ide_drive_t * drive = container_of(dev,ide_drive_t,gendev);
ide_driver_t * driver = drive->driver;
if (driver) {
if (driver->standby)
driver->standby(drive);
if (driver->cleanup)
driver->cleanup(drive);
}
return 0;
}
int ide_register_driver(ide_driver_t *driver)
{
struct list_head list;
......@@ -3440,7 +3456,10 @@ int ide_register_driver(ide_driver_t *driver)
list_del_init(&drive->list);
ata_attach(drive);
}
return 0;
driver->gen_driver.name = driver->name;
driver->gen_driver.bus = &ide_bus_type;
driver->gen_driver.remove = ide_drive_remove;
return driver_register(&driver->gen_driver);
}
EXPORT_SYMBOL(ide_register_driver);
......@@ -3491,52 +3510,6 @@ EXPORT_SYMBOL(ide_lock);
EXPORT_SYMBOL(ide_probe);
EXPORT_SYMBOL(ide_devfs_handle);
static int ide_notify_reboot (struct notifier_block *this, unsigned long event, void *x)
{
ide_hwif_t *hwif;
ide_drive_t *drive;
int i, unit;
switch (event) {
case SYS_HALT:
case SYS_POWER_OFF:
case SYS_RESTART:
break;
default:
return NOTIFY_DONE;
}
printk(KERN_INFO "flushing ide devices: ");
for (i = 0; i < MAX_HWIFS; i++) {
hwif = &ide_hwifs[i];
if (!hwif->present)
continue;
for (unit = 0; unit < MAX_DRIVES; ++unit) {
drive = &hwif->drives[unit];
if (!drive->present)
continue;
/* set the drive to standby */
printk("%s ", drive->name);
if (event != SYS_RESTART)
if (drive->driver != NULL && DRIVER(drive)->standby(drive))
continue;
if (drive->driver != NULL && DRIVER(drive)->cleanup(drive))
continue;
}
}
printk("\n");
return NOTIFY_DONE;
}
static struct notifier_block ide_notifier = {
ide_notify_reboot,
NULL,
5
};
struct bus_type ide_bus_type = {
.name = "ide",
};
......@@ -3562,7 +3535,6 @@ int __init ide_init (void)
ide_init_builtin_drivers();
initializing = 0;
register_reboot_notifier(&ide_notifier);
return 0;
}
......@@ -3597,7 +3569,6 @@ void cleanup_module (void)
{
int index;
unregister_reboot_notifier(&ide_notifier);
for (index = 0; index < MAX_HWIFS; ++index) {
ide_unregister(index);
#if defined(CONFIG_BLK_DEV_IDEDMA) && !defined(CONFIG_DMA_NONPCI)
......
drivers/net/3c501.c
View file @ 994b3fb0
......@@ -11,12 +11,11 @@
Do not purchase this card, even as a joke. It's performance is horrible,
and it breaks in many ways.
The author may be reached as becker@scyld.com, or C/O
The original author may be reached as becker@scyld.com, or C/O
Scyld Computing Corporation
410 Severn Ave., Suite 210
Annapolis MD 21403
Fixed (again!) the missing interrupt locking on TX/RX shifting.
Alan Cox <Alan.Cox@linux.org>
......@@ -35,6 +34,15 @@
Cleaned up for 2.3.x because we broke SMP now.
20000208 Alan Cox <alan@redhat.com>
Check up pass for 2.5. Nothing significant changed
20021009 Alan Cox <alan@redhat.com>
For the avoidance of doubt the "preferred form" of this code is one which
is in an open non patent encumbered format. Where cryptographic key signing
forms part of the process of creating an executable the information
including keys needed to generate an equivalently functional executable
are deemed to be part of the source code.
*/
......@@ -88,7 +96,7 @@
*/
#define DRV_NAME "3c501"
#define DRV_VERSION "2001/11/17"
#define DRV_VERSION "2002/10/09"
static const char version[] =
......@@ -122,113 +130,21 @@ static const char version[] =
#include <linux/skbuff.h>
#include <linux/init.h>
#include "3c501.h"
/* A zero-terminated list of I/O addresses to be probed.
The 3c501 can be at many locations, but here are the popular ones. */
static unsigned int netcard_portlist[] __initdata = {
0x280, 0x300, 0
};
/*
* Index to functions.
*/
int el1_probe(struct net_device *dev);
static int el1_probe1(struct net_device *dev, int ioaddr);
static int el_open(struct net_device *dev);
static void el_timeout(struct net_device *dev);
static int el_start_xmit(struct sk_buff *skb, struct net_device *dev);
static void el_interrupt(int irq, void *dev_id, struct pt_regs *regs);
static void el_receive(struct net_device *dev);
static void el_reset(struct net_device *dev);
static int el1_close(struct net_device *dev);
static struct net_device_stats *el1_get_stats(struct net_device *dev);
static void set_multicast_list(struct net_device *dev);
static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
#define EL1_IO_EXTENT 16
#ifndef EL_DEBUG
#define EL_DEBUG 0 /* use 0 for production, 1 for devel., >2 for debug */
#endif /* Anything above 5 is wordy death! */
#define debug el_debug
static int el_debug = EL_DEBUG;
/*
* Board-specific info in dev->priv.
*/
struct net_local
{
struct net_device_stats stats;
int tx_pkt_start; /* The length of the current Tx packet. */
int collisions; /* Tx collisions this packet */
int loading; /* Spot buffer load collisions */
int txing; /* True if card is in TX mode */
spinlock_t lock; /* Serializing lock */
};
#define RX_STATUS (ioaddr + 0x06)
#define RX_CMD RX_STATUS
#define TX_STATUS (ioaddr + 0x07)
#define TX_CMD TX_STATUS
#define GP_LOW (ioaddr + 0x08)
#define GP_HIGH (ioaddr + 0x09)
#define RX_BUF_CLR (ioaddr + 0x0A)
#define RX_LOW (ioaddr + 0x0A)
#define RX_HIGH (ioaddr + 0x0B)
#define SAPROM (ioaddr + 0x0C)
#define AX_STATUS (ioaddr + 0x0E)
#define AX_CMD AX_STATUS
#define DATAPORT (ioaddr + 0x0F)
#define TX_RDY 0x08 /* In TX_STATUS */
#define EL1_DATAPTR 0x08
#define EL1_RXPTR 0x0A
#define EL1_SAPROM 0x0C
#define EL1_DATAPORT 0x0f
/*
* Writes to the ax command register.
*/
#define AX_OFF 0x00 /* Irq off, buffer access on */
#define AX_SYS 0x40 /* Load the buffer */
#define AX_XMIT 0x44 /* Transmit a packet */
#define AX_RX 0x48 /* Receive a packet */
#define AX_LOOP 0x0C /* Loopback mode */
#define AX_RESET 0x80
/*
* Normal receive mode written to RX_STATUS. We must intr on short packets
* to avoid bogus rx lockups.
*/
#define RX_NORM 0xA8 /* 0x68 == all addrs, 0xA8 only to me. */
#define RX_PROM 0x68 /* Senior Prom, uhmm promiscuous mode. */
#define RX_MULT 0xE8 /* Accept multicast packets. */
#define TX_NORM 0x0A /* Interrupt on everything that might hang the chip */
/*
* TX_STATUS register.
*/
#define TX_COLLISION 0x02
#define TX_16COLLISIONS 0x04
#define TX_READY 0x08
#define RX_RUNT 0x08
#define RX_MISSED 0x01 /* Missed a packet due to 3c501 braindamage. */
#define RX_GOOD 0x30 /* Good packet 0x20, or simple overflow 0x10. */
/*
* The boilerplate probe code.
*/
/**
* el1_probe:
* el1_probe: - probe for a 3c501
* @dev: The device structure passed in to probe.
*
* This can be called from two places. The network layer will probe using
......@@ -556,7 +472,6 @@ static int el_start_xmit(struct sk_buff *skb, struct net_device *dev)
while(1);
}
/**
* el_interrupt:
......@@ -1072,12 +987,8 @@ void cleanup_module(void)
}
#endif /* MODULE */
MODULE_AUTHOR("Donald Becker, Alan Cox");
MODULE_DESCRIPTION("Support for the ancient 3Com 3c501 ethernet card");
MODULE_LICENSE("GPL");
/*
* Local variables:
* compile-command: "gcc -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer -m486 -c -o 3c501.o 3c501.c"
* kept-new-versions: 5
* End:
*/
drivers/net/3c501.h 0 → 100644
View file @ 994b3fb0
/*
* Index to functions.
*/
int el1_probe(struct net_device *dev);
static int el1_probe1(struct net_device *dev, int ioaddr);
static int el_open(struct net_device *dev);
static void el_timeout(struct net_device *dev);
static int el_start_xmit(struct sk_buff *skb, struct net_device *dev);
static void el_interrupt(int irq, void *dev_id, struct pt_regs *regs);
static void el_receive(struct net_device *dev);
static void el_reset(struct net_device *dev);
static int el1_close(struct net_device *dev);
static struct net_device_stats *el1_get_stats(struct net_device *dev);
static void set_multicast_list(struct net_device *dev);
static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
#define EL1_IO_EXTENT 16
#ifndef EL_DEBUG
#define EL_DEBUG 0 /* use 0 for production, 1 for devel., >2 for debug */
#endif /* Anything above 5 is wordy death! */
#define debug el_debug
static int el_debug = EL_DEBUG;
/*
* Board-specific info in dev->priv.
*/
struct net_local
{
struct net_device_stats stats;
int tx_pkt_start; /* The length of the current Tx packet. */
int collisions; /* Tx collisions this packet */
int loading; /* Spot buffer load collisions */
int txing; /* True if card is in TX mode */
spinlock_t lock; /* Serializing lock */
};
#define RX_STATUS (ioaddr + 0x06)
#define RX_CMD RX_STATUS
#define TX_STATUS (ioaddr + 0x07)
#define TX_CMD TX_STATUS
#define GP_LOW (ioaddr + 0x08)
#define GP_HIGH (ioaddr + 0x09)
#define RX_BUF_CLR (ioaddr + 0x0A)
#define RX_LOW (ioaddr + 0x0A)
#define RX_HIGH (ioaddr + 0x0B)
#define SAPROM (ioaddr + 0x0C)
#define AX_STATUS (ioaddr + 0x0E)
#define AX_CMD AX_STATUS
#define DATAPORT (ioaddr + 0x0F)
#define TX_RDY 0x08 /* In TX_STATUS */
#define EL1_DATAPTR 0x08
#define EL1_RXPTR 0x0A
#define EL1_SAPROM 0x0C
#define EL1_DATAPORT 0x0f
/*
* Writes to the ax command register.
*/
#define AX_OFF 0x00 /* Irq off, buffer access on */
#define AX_SYS 0x40 /* Load the buffer */
#define AX_XMIT 0x44 /* Transmit a packet */
#define AX_RX 0x48 /* Receive a packet */
#define AX_LOOP 0x0C /* Loopback mode */
#define AX_RESET 0x80
/*
* Normal receive mode written to RX_STATUS. We must intr on short packets
* to avoid bogus rx lockups.
*/
#define RX_NORM 0xA8 /* 0x68 == all addrs, 0xA8 only to me. */
#define RX_PROM 0x68 /* Senior Prom, uhmm promiscuous mode. */
#define RX_MULT 0xE8 /* Accept multicast packets. */
#define TX_NORM 0x0A /* Interrupt on everything that might hang the chip */
/*
* TX_STATUS register.
*/
#define TX_COLLISION 0x02
#define TX_16COLLISIONS 0x04
#define TX_READY 0x08
#define RX_RUNT 0x08
#define RX_MISSED 0x01 /* Missed a packet due to 3c501 braindamage. */
#define RX_GOOD 0x30 /* Good packet 0x20, or simple overflow 0x10. */
drivers/scsi/cpqfcTSstructs.h
View file @ 994b3fb0
......@@ -21,7 +21,6 @@
#define CPQFCTSSTRUCTS_H
#include <linux/timer.h> // timer declaration in our host data
#include <linux/tqueue.h> // task queue sched
#include <asm/atomic.h>
#include "cpqfcTSioctl.h"
......
drivers/scsi/in2000.c
View file @ 994b3fb0
......@@ -317,13 +317,15 @@ uchar result;
static void in2000_execute(struct Scsi_Host *instance);
int in2000_queuecommand (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
static int in2000_queuecommand (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
{
struct Scsi_Host *instance;
struct IN2000_hostdata *hostdata;
Scsi_Cmnd *tmp;
unsigned long flags;
hostdata = (struct IN2000_hostdata *)cmd->host->hostdata;
instance = cmd->host;
hostdata = (struct IN2000_hostdata *)instance->hostdata;
DB(DB_QUEUE_COMMAND,printk("Q-%d-%02x-%ld(",cmd->target,cmd->cmnd[0],cmd->pid))
......@@ -355,7 +357,7 @@ DB(DB_QUEUE_COMMAND,printk("Q-%d-%02x-%ld(",cmd->target,cmd->cmnd[0],cmd->pid))
if (cmd->use_sg) {
cmd->SCp.buffer = (struct scatterlist *)cmd->buffer;
cmd->SCp.buffers_residual = cmd->use_sg - 1;
cmd->SCp.ptr = (char *)cmd->SCp.buffer->address;
cmd->SCp.ptr = (char *)page_address(cmd->SCp.buffer->page)+cmd->SCp.buffer->offset;
cmd->SCp.this_residual = cmd->SCp.buffer->length;
}
else {
......@@ -391,9 +393,7 @@ DB(DB_QUEUE_COMMAND,printk("Q-%d-%02x-%ld(",cmd->target,cmd->cmnd[0],cmd->pid))
* queue and calling in2000_execute().
*/
save_flags(flags);
cli();
spin_lock_irqsave(instance->host_lock, flags);
/*
* Add the cmd to the end of 'input_Q'. Note that REQUEST_SENSE
* commands are added to the head of the queue so that the desired
......@@ -418,8 +418,7 @@ DB(DB_QUEUE_COMMAND,printk("Q-%d-%02x-%ld(",cmd->target,cmd->cmnd[0],cmd->pid))
in2000_execute(cmd->host);
DB(DB_QUEUE_COMMAND,printk(")Q-%ld ",cmd->pid))
restore_flags(flags);
spin_unlock_irqrestore(instance->host_lock, flags);
return 0;
}
......@@ -762,7 +761,7 @@ int i;
++cmd->SCp.buffer;
--cmd->SCp.buffers_residual;
cmd->SCp.this_residual = cmd->SCp.buffer->length;
cmd->SCp.ptr = cmd->SCp.buffer->address;
cmd->SCp.ptr = page_address(cmd->SCp.buffer->page) + cmd->SCp.buffer->offset;
}
/* Set up hardware registers */
......@@ -855,7 +854,7 @@ unsigned long flags;
/* Get the spin_lock and disable further ints, for SMP */
CLISPIN_LOCK(instance, flags);
spin_lock_irqsave(instance->host_lock, flags);
#ifdef PROC_STATISTICS
hostdata->int_cnt++;
......@@ -993,7 +992,7 @@ DB(DB_FIFO,printk("{W:%02x} ",read1_io(IO_FIFO_COUNT)))
write1_io(0, IO_LED_OFF);
/* release the SMP spin_lock and restore irq state */
CLISPIN_UNLOCK(instance, flags);
spin_unlock_irqrestore(instance->host_lock, flags);
return;
}
......@@ -1011,7 +1010,7 @@ DB(DB_FIFO,printk("{W:%02x} ",read1_io(IO_FIFO_COUNT)))
write1_io(0, IO_LED_OFF);
/* release the SMP spin_lock and restore irq state */
CLISPIN_UNLOCK(instance, flags);
spin_unlock_irqrestore(instance->host_lock, flags);
return;
}
......@@ -1433,7 +1432,7 @@ DB(DB_INTR,printk("%02x",hostdata->outgoing_msg[0]))
hostdata->state = S_UNCONNECTED;
/* release the SMP spin_lock and restore irq state */
CLISPIN_UNLOCK(instance, flags);
spin_unlock_irqrestore(instance->host_lock, flags);
return;
}
DB(DB_INTR,printk("UNEXP_DISC-%ld",cmd->pid))
......@@ -1609,7 +1608,7 @@ DB(DB_INTR,printk("-%ld",cmd->pid))
DB(DB_INTR,printk("} "))
/* release the SMP spin_lock and restore irq state */
CLISPIN_UNLOCK(instance, flags);
spin_unlock_irqrestore(instance->host_lock, flags);
}
......@@ -1619,11 +1618,14 @@ DB(DB_INTR,printk("} "))
#define RESET_CARD_AND_BUS 1
#define B_FLAG 0x80
/*
* Caller must hold instance lock!
*/
static int reset_hardware(struct Scsi_Host *instance, int type)
{
struct IN2000_hostdata *hostdata;
int qt,x;
unsigned long flags;
hostdata = (struct IN2000_hostdata *)instance->hostdata;
......@@ -1638,16 +1640,16 @@ unsigned long flags;
write_3393(hostdata,WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
write_3393(hostdata,WD_SYNCHRONOUS_TRANSFER,
calc_sync_xfer(hostdata->default_sx_per/4,DEFAULT_SX_OFF));
save_flags(flags);
cli();
write1_io(0,IO_FIFO_WRITE); /* clear fifo counter */
write1_io(0,IO_FIFO_READ); /* start fifo out in read mode */
write_3393(hostdata,WD_COMMAND, WD_CMD_RESET);
/* FIXME: timeout ?? */
while (!(READ_AUX_STAT() & ASR_INT))
; /* wait for RESET to complete */
cpu_relax(); /* wait for RESET to complete */
x = read_3393(hostdata,WD_SCSI_STATUS); /* clear interrupt */
restore_flags(flags);
write_3393(hostdata,WD_QUEUE_TAG,0xa5); /* any random number */
qt = read_3393(hostdata,WD_QUEUE_TAG);
if (qt == 0xa5) {
......@@ -1662,7 +1664,7 @@ unsigned long flags;
int in2000_reset(Scsi_Cmnd *cmd, unsigned int reset_flags)
static int in2000_bus_reset(Scsi_Cmnd *cmd)
{
unsigned long flags;
struct Scsi_Host *instance;
......@@ -1672,10 +1674,9 @@ int x;
instance = cmd->host;
hostdata = (struct IN2000_hostdata *)instance->hostdata;
printk("scsi%d: Reset. ", instance->host_no);
save_flags(flags);
cli();
printk(KERN_WARNING "scsi%d: Reset. ", instance->host_no);
spin_lock_irqsave(instance->host_lock, flags);
/* do scsi-reset here */
reset_hardware(instance, RESET_CARD_AND_BUS);
......@@ -1694,13 +1695,22 @@ int x;
hostdata->outgoing_len = 0;
cmd->result = DID_RESET << 16;
restore_flags(flags);
return 0;
spin_unlock_irqrestore(instance->host_lock, flags);
return SUCCESS;
}
static int in2000_host_reset(Scsi_Cmnd *cmd)
{
return FAILED;
}
static int in2000_device_reset(Scsi_Cmnd *cmd)
{
return FAILED;
}
int in2000_abort (Scsi_Cmnd *cmd)
static int in2000_abort (Scsi_Cmnd *cmd)
{
struct Scsi_Host *instance;
struct IN2000_hostdata *hostdata;
......@@ -1709,13 +1719,10 @@ unsigned long flags;
uchar sr, asr;
unsigned long timeout;
save_flags (flags);
cli();
instance = cmd->host;
hostdata = (struct IN2000_hostdata *)instance->hostdata;
printk ("scsi%d: Abort-", instance->host_no);
printk(KERN_DEBUG "scsi%d: Abort-", instance->host_no);
printk("(asr=%02x,count=%ld,resid=%d,buf_resid=%d,have_data=%d,FC=%02x)- ",
READ_AUX_STAT(),read_3393_count(hostdata),cmd->SCp.this_residual,cmd->SCp.buffers_residual,
cmd->SCp.have_data_in,read1_io(IO_FIFO_COUNT));
......@@ -1725,6 +1732,7 @@ unsigned long timeout;
* from the inout_Q.
*/
spin_lock_irqsave(instance->host_lock, flags);
tmp = (Scsi_Cmnd *)hostdata->input_Q;
prev = 0;
while (tmp) {
......@@ -1733,11 +1741,11 @@ unsigned long timeout;
prev->host_scribble = cmd->host_scribble;
cmd->host_scribble = NULL;
cmd->result = DID_ABORT << 16;
printk("scsi%d: Abort - removing command %ld from input_Q. ",
printk(KERN_WARNING "scsi%d: Abort - removing command %ld from input_Q. ",
instance->host_no, cmd->pid);
cmd->scsi_done(cmd);
restore_flags(flags);
return SCSI_ABORT_SUCCESS;
spin_unlock_irqrestore(instance->host_lock, flags);
return SUCCESS;
}
prev = tmp;
tmp = (Scsi_Cmnd *)tmp->host_scribble;
......@@ -1756,7 +1764,7 @@ unsigned long timeout;
if (hostdata->connected == cmd) {
printk("scsi%d: Aborting connected command %ld - ",
printk(KERN_WARNING "scsi%d: Aborting connected command %ld - ",
instance->host_no, cmd->pid);
printk("sending wd33c93 ABORT command - ");
......@@ -1800,7 +1808,6 @@ unsigned long timeout;
in2000_execute (instance);
restore_flags(flags);
return SCSI_ABORT_SUCCESS;
}
......@@ -1813,9 +1820,9 @@ unsigned long timeout;
for (tmp=(Scsi_Cmnd *)hostdata->disconnected_Q; tmp;
tmp=(Scsi_Cmnd *)tmp->host_scribble)
if (cmd == tmp) {
restore_flags(flags);
printk("Sending ABORT_SNOOZE. ");
return SCSI_ABORT_SNOOZE;
spin_unlock_irqrestore(instance->host_lock, flags);
printk(KERN_DEBUG "scsi%d: unable to abort disconnected command.\n", instance->host_no);
return FAILED;
}
/*
......@@ -1830,10 +1837,10 @@ unsigned long timeout;
in2000_execute (instance);
restore_flags(flags);
spin_unlock_irqrestore(instance->host_lock, flags);
printk("scsi%d: warning : SCSI command probably completed successfully"
" before abortion. ", instance->host_no);
return SCSI_ABORT_NOT_RUNNING;
return SUCCESS;
}
......@@ -1845,7 +1852,7 @@ static char setup_buffer[SETUP_BUFFER_SIZE];
static char setup_used[MAX_SETUP_ARGS];
static int done_setup = 0;
void __init in2000_setup (char *str, int *ints)
static void __init in2000_setup (char *str, int *ints)
{
int i;
char *p1,*p2;
......@@ -1931,7 +1938,7 @@ static const int int_tab[] in2000__INITDATA = {
};
int __init in2000_detect(Scsi_Host_Template * tpnt)
static int __init in2000_detect(Scsi_Host_Template * tpnt)
{
struct Scsi_Host *instance;
struct IN2000_hostdata *hostdata;
......@@ -2115,7 +2122,11 @@ char buf[32];
#endif
/* FIXME: not strictly needed I think but the called code expects
to be locked */
spin_lock_irqsave(instance->host_lock, flags);
x = reset_hardware(instance,(hostdata->args & A_NO_SCSI_RESET)?RESET_CARD:RESET_CARD_AND_BUS);
spin_unlock_irqrestore(instance->host_lock, flags);
hostdata->microcode = read_3393(hostdata,WD_CDB_1);
if (x & 0x01) {
......@@ -2158,7 +2169,7 @@ char buf[32];
* supposed to do...
*/
int in2000_biosparam(Disk *disk, struct block_device *dev, int *iinfo)
static int in2000_biosparam(Disk *disk, struct block_device *dev, int *iinfo)
{
int size;
......@@ -2190,7 +2201,7 @@ int size;
}
int in2000_proc_info(char *buf, char **start, off_t off, int len, int hn, int in)
static int in2000_proc_info(char *buf, char **start, off_t off, int len, int hn, int in)
{
#ifdef PROC_INTERFACE
......@@ -2260,8 +2271,7 @@ static int stop = 0;
return len;
}
save_flags(flags);
cli();
spin_lock_irqsave(instance->host_lock, flags);
bp = buf;
*bp = '\0';
if (hd->proc & PR_VERSION) {
......@@ -2340,7 +2350,7 @@ static int stop = 0;
; /* insert your own custom function here */
}
strcat(bp,"\n");
restore_flags(flags);
spin_unlock_irqrestore(instance->host_lock, flags);
*start = buf;
if (stop) {
stop = 0;
......
drivers/scsi/in2000.h
View file @ 994b3fb0
......@@ -397,13 +397,15 @@ struct IN2000_hostdata {
# define CLISPIN_UNLOCK(host,flags) spin_unlock_irqrestore(host->host_lock, \
flags)
int in2000_detect(Scsi_Host_Template *) in2000__INIT;
int in2000_queuecommand(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
int in2000_abort(Scsi_Cmnd *);
void in2000_setup(char *, int *) in2000__INIT;
int in2000_proc_info(char *, char **, off_t, int, int, int);
int in2000_biosparam(struct scsi_disk *, struct block_device *, int *);
int in2000_reset(Scsi_Cmnd *, unsigned int);
static int in2000_detect(Scsi_Host_Template *) in2000__INIT;
static int in2000_queuecommand(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
static int in2000_abort(Scsi_Cmnd *);
static void in2000_setup(char *, int *) in2000__INIT;
static int in2000_proc_info(char *, char **, off_t, int, int, int);
static int in2000_biosparam(struct scsi_disk *, struct block_device *, int *);
static int in2000_host_reset(Scsi_Cmnd *);
static int in2000_bus_reset(Scsi_Cmnd *);
static int in2000_device_reset(Scsi_Cmnd *);
#define IN2000_CAN_Q 16
......@@ -416,8 +418,10 @@ int in2000_reset(Scsi_Cmnd *, unsigned int);
name: "Always IN2000", /* device name */ \
detect: in2000_detect, /* returns number of in2000's found */ \
queuecommand: in2000_queuecommand, /* queue scsi command, don't wait */ \
abort: in2000_abort, /* abort current command */ \
reset: in2000_reset, /* reset scsi bus */ \
eh_abort_handler: in2000_abort, /* abort current command */ \
eh_bus_reset_handler: in2000_bus_reset, /* reset scsi bus */ \
eh_device_reset_handler: in2000_device_reset, /* reset scsi device */ \
eh_host_reset_handler: in2000_host_reset, /* reset scsi hba */ \
bios_param: in2000_biosparam, /* figures out BIOS parameters for lilo, etc */ \
can_queue: IN2000_CAN_Q, /* max commands we can queue up */ \
this_id: IN2000_HOST_ID, /* host-adapter scsi id */ \
......
drivers/scsi/ips.c
View file @ 994b3fb0
/*****************************************************************************/
/* ips.c -- driver for the IBM ServeRAID controller */
/* ips.c -- driver for the Adaptec / IBM ServeRAID controller */
/* */
/* Written By: Keith Mitchell, IBM Corporation */
/* Jack Hammer, Adaptec, Inc. */
/* David Jeffery, Adaptec, Inc. */
/* */
/* Copyright (C) 2000 IBM Corporation */
/* Copyright (C) 2002 Adaptec, Inc. */
/* */
/* 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 */
......@@ -42,7 +43,7 @@
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/* */
/* Bugs/Comments/Suggestions about this driver should be mailed to: */
/* ipslinux@us.ibm.com */
/* ipslinux@adaptec.com */
/* */
/* For system support issues, contact your local IBM Customer support. */
/* Directions to find IBM Customer Support for each country can be found at: */
......@@ -66,9 +67,8 @@
/* 0.99.05 - Fix an oops when we get certain passthru commands */
/* 1.00.00 - Initial Public Release */
/* Functionally equivalent to 0.99.05 */
/* 3.60.00 - Bump max commands to 128 for use with ServeRAID firmware 3.60 */
/* - Change version to 3.60 to coincide with ServeRAID release */
/* numbering. */
/* 3.60.00 - Bump max commands to 128 for use with firmware 3.60 */
/* - Change version to 3.60 to coincide with release numbering. */
/* 3.60.01 - Remove bogus error check in passthru routine */
/* 3.60.02 - Make DCDB direction based on lookup table */
/* - Only allow one DCDB command to a SCSI ID at a time */
......@@ -76,7 +76,7 @@
/* 4.00.01 - Add support for First Failure Data Capture */
/* 4.00.02 - Fix problem with PT DCDB with no buffer */
/* 4.00.03 - Add alternative passthru interface */
/* - Add ability to flash ServeRAID BIOS */
/* - Add ability to flash BIOS */
/* 4.00.04 - Rename structures/constants to be prefixed with IPS_ */
/* 4.00.05 - Remove wish_block from init routine */
/* - Use linux/spinlock.h instead of asm/spinlock.h for kernels */
......@@ -158,9 +158,7 @@
#include <linux/kernel.h>
#include <linux/ioport.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/pci.h>
#include <linux/proc_fs.h>
#include <linux/reboot.h>
......@@ -222,7 +220,7 @@ struct proc_dir_entry proc_scsi_ips = {
dma_addr_t *dmahandle) {
void * ptr = kmalloc(size, GFP_ATOMIC);
if(ptr){
*dmahandle = VIRT_TO_BUS(ptr);
*dmahandle = (uint32_t)virt_to_bus(ptr);
}
return ptr;
}
......@@ -231,10 +229,10 @@ struct proc_dir_entry proc_scsi_ips = {
#define pci_map_sg(a,b,n,z) (n)
#define pci_unmap_sg(a,b,c,d)
#define pci_map_single(a,b,c,d) (VIRT_TO_BUS(b))
#define pci_map_single(a,b,c,d) ((uint32_t)virt_to_bus(b))
#define pci_unmap_single(a,b,c,d)
#ifndef sg_dma_address
#define sg_dma_address(x) (VIRT_TO_BUS((x)->address))
#define sg_dma_address(x) ((uint32_t)virt_to_bus((x)->address))
#define sg_dma_len(x) ((x)->length)
#endif
#define pci_unregister_driver(x)
......@@ -242,18 +240,16 @@ struct proc_dir_entry proc_scsi_ips = {
#if LINUX_VERSION_CODE <= LinuxVersionCode(2,5,0)
#define IPS_SG_ADDRESS(sg) ((sg)->address)
#define IPS_LOCK_IRQ(lock) spin_lock_irq(&io_request_lock)
#define IPS_UNLOCK_IRQ(lock) spin_unlock_irq(&io_request_lock)
#define IPS_LOCK_SAVE(lock,flags) spin_lock_irqsave(&io_request_lock,flags)
#define IPS_UNLOCK_RESTORE(lock,flags) spin_unlock_irqrestore(&io_request_lock,flags)
#ifndef __devexit_p
#define __devexit_p(x) x
#endif
#else
#define IPS_SG_ADDRESS(sg) (page_address((sg)->page) ? \
page_address((sg)->page)+(sg)->offset : 0)
#define IPS_LOCK_IRQ(lock) spin_lock_irq(lock)
#define IPS_UNLOCK_IRQ(lock) spin_unlock_irq(lock)
#define IPS_LOCK_SAVE(lock,flags) spin_lock_irqsave(lock,flags)
#define IPS_UNLOCK_RESTORE(lock,flags) spin_unlock_irqrestore(lock,flags)
#define IPS_LOCK_SAVE(lock,flags) spin_lock(lock)
#define IPS_UNLOCK_RESTORE(lock,flags) spin_unlock(lock)
#endif
#define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
......@@ -532,6 +528,7 @@ static void copy_mem_info(IPS_INFOSTR *, char *, int);
static int copy_info(IPS_INFOSTR *, char *, ...);
static int ips_get_version_info(ips_ha_t *ha, IPS_VERSION_DATA *Buffer, int intr );
static void ips_version_check(ips_ha_t *ha, int intr);
static int ips_abort_init(ips_ha_t *ha, struct Scsi_Host *sh, int index);
static int ips_init_phase2( int index );
#if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
......@@ -962,14 +959,6 @@ ips_detect(Scsi_Host_Template *SHT) {
ha = IPS_HA(sh);
memset(ha, 0, sizeof(ips_ha_t));
/* Initialize spin lock */
spin_lock_init(&ha->scb_lock);
spin_lock_init(&ha->copp_lock);
spin_lock_init(&ha->ips_lock);
spin_lock_init(&ha->copp_waitlist.lock);
spin_lock_init(&ha->scb_waitlist.lock);
spin_lock_init(&ha->scb_activelist.lock);
ips_sh[ips_next_controller] = sh;
ips_ha[ips_next_controller] = ha;
ips_num_controllers++;
......@@ -1416,12 +1405,13 @@ ips_halt(struct notifier_block *nb, ulong event, void *buf) {
/* Routine Description: */
/* */
/* Abort a command (using the new error code stuff) */
/* */
/* Note: this routine is called under the io_request_lock */
/****************************************************************************/
int
ips_eh_abort(Scsi_Cmnd *SC) {
ips_ha_t *ha;
ips_copp_wait_item_t *item;
int ret;
METHOD_TRACE("ips_eh_abort", 1);
......@@ -1443,36 +1433,25 @@ ips_eh_abort(Scsi_Cmnd *SC) {
return (FAILED);
}
if (test_and_set_bit(IPS_IN_ABORT, &ha->flags))
return (FAILED);
/* See if the command is on the copp queue */
IPS_QUEUE_LOCK(&ha->copp_waitlist);
item = ha->copp_waitlist.head;
while ((item) && (item->scsi_cmd != SC))
item = item->next;
IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
if (item) {
/* Found it */
ips_removeq_copp(&ha->copp_waitlist, item);
clear_bit(IPS_IN_ABORT, &ha->flags);
return (SUCCESS);
}
ret = (SUCCESS);
/* See if the command is on the wait queue */
if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
} else if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
/* command not sent yet */
clear_bit(IPS_IN_ABORT, &ha->flags);
return (SUCCESS);
ret = (SUCCESS);
} else {
/* command must have already been sent */
clear_bit(IPS_IN_ABORT, &ha->flags);
return (FAILED);
ret = (FAILED);
}
return ret;
}
/****************************************************************************/
......@@ -1493,7 +1472,6 @@ ips_eh_reset(Scsi_Cmnd *SC) {
ips_ha_t *ha;
ips_scb_t *scb;
ips_copp_wait_item_t *item;
unsigned long cpu_flags;
METHOD_TRACE("ips_eh_reset", 1);
......@@ -1518,36 +1496,27 @@ ips_eh_reset(Scsi_Cmnd *SC) {
if (!ha->active)
return (FAILED);
if (test_and_set_bit(IPS_IN_RESET, &ha->flags))
return (FAILED);
/* See if the command is on the copp queue */
IPS_QUEUE_LOCK(&ha->copp_waitlist);
item = ha->copp_waitlist.head;
while ((item) && (item->scsi_cmd != SC))
item = item->next;
IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
if (item) {
/* Found it */
ips_removeq_copp(&ha->copp_waitlist, item);
clear_bit(IPS_IN_RESET, &ha->flags);
return (SUCCESS);
}
/* See if the command is on the wait queue */
if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
/* command not sent yet */
clear_bit(IPS_IN_RESET, &ha->flags);
return (SUCCESS);
}
/* An explanation for the casual observer: */
/* Part of the function of a RAID controller is automatic error */
/* detection and recovery. As such, the only problem that physically */
/* resetting a ServeRAID adapter will ever fix is when, for some reason,*/
/* resetting an adapter will ever fix is when, for some reason, */
/* the driver is not successfully communicating with the adapter. */
/* Therefore, we will attempt to flush this adapter. If that succeeds, */
/* then there's no real purpose in a physical reset. This will complete */
......@@ -1574,13 +1543,12 @@ ips_eh_reset(Scsi_Cmnd *SC) {
ret = ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_IORL);
if (ret == IPS_SUCCESS) {
printk(KERN_NOTICE "(%s%d) Reset Request - Flushed Cache\n", ips_name, ha->host_num);
clear_bit(IPS_IN_RESET, &ha->flags);
return (SUCCESS);
}
}
/* Either we can't communicate with the adapter or it's an IOCTL request */
/* from a ServeRAID utility. A physical reset is needed at this point. */
/* from a utility. A physical reset is needed at this point. */
ha->ioctl_reset = 0; /* Reset the IOCTL Requested Reset Flag */
......@@ -1619,8 +1587,6 @@ ips_eh_reset(Scsi_Cmnd *SC) {
}
ha->active = FALSE;
clear_bit(IPS_IN_RESET, &ha->flags);
return (FAILED);
}
......@@ -1651,8 +1617,6 @@ ips_eh_reset(Scsi_Cmnd *SC) {
}
ha->active = FALSE;
clear_bit(IPS_IN_RESET, &ha->flags);
return (FAILED);
}
......@@ -1661,10 +1625,8 @@ ips_eh_reset(Scsi_Cmnd *SC) {
struct timeval tv;
do_gettimeofday(&tv);
IPS_HA_LOCK(cpu_flags);
ha->last_ffdc = tv.tv_sec;
ha->reset_count++;
IPS_HA_UNLOCK(cpu_flags);
ips_ffdc_reset(ha, IPS_INTR_IORL);
}
......@@ -1683,25 +1645,11 @@ ips_eh_reset(Scsi_Cmnd *SC) {
ha->dcdb_active[i-1] = 0;
/* Reset the number of active IOCTLs */
IPS_HA_LOCK(cpu_flags);
ha->num_ioctl = 0;
IPS_HA_UNLOCK(cpu_flags);
clear_bit(IPS_IN_RESET, &ha->flags);
if (!test_bit(IPS_IN_INTR, &ha->flags)) {
/*
* Only execute the next command when
* we are not being called from the
* interrupt handler. The interrupt
* handler wants to do this and since
* interrupts are turned off here....
*/
ips_next(ha, IPS_INTR_IORL);
}
return (SUCCESS);
#endif /* NO_IPS_RESET */
}
......@@ -1721,7 +1669,6 @@ ips_eh_reset(Scsi_Cmnd *SC) {
int
ips_queue(Scsi_Cmnd *SC, void (*done) (Scsi_Cmnd *)) {
ips_ha_t *ha;
unsigned long cpu_flags;
ips_passthru_t *pt;
METHOD_TRACE("ips_queue", 1);
......@@ -1735,28 +1682,17 @@ ips_queue(Scsi_Cmnd *SC, void (*done) (Scsi_Cmnd *)) {
return (DID_ERROR);
if (ips_is_passthru(SC)) {
IPS_QUEUE_LOCK(&ha->copp_waitlist);
if (ha->copp_waitlist.count == IPS_MAX_IOCTL_QUEUE) {
IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
SC->result = DID_BUS_BUSY << 16;
done(SC);
return (0);
} else {
IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
}
} else {
IPS_QUEUE_LOCK(&ha->scb_waitlist);
if (ha->scb_waitlist.count == IPS_MAX_QUEUE) {
IPS_QUEUE_UNLOCK(&ha->scb_waitlist);
} else if (ha->scb_waitlist.count == IPS_MAX_QUEUE) {
SC->result = DID_BUS_BUSY << 16;
done(SC);
return (0);
} else {
IPS_QUEUE_UNLOCK(&ha->scb_waitlist);
}
}
SC->scsi_done = done;
......@@ -1810,27 +1746,15 @@ ips_queue(Scsi_Cmnd *SC, void (*done) (Scsi_Cmnd *)) {
}
scratch->scsi_cmd = SC;
sema_init(&ha->ioctl_sem, 0);
scratch->sem = &ha->ioctl_sem;
scratch->next = NULL;
ips_putq_copp_tail(&ha->copp_waitlist, scratch);
}
else
else {
ips_putq_wait_tail(&ha->scb_waitlist, SC);
}
if(ha->scb_waitlist.count + ha->scb_activelist.count > 32)
mod_timer(&SC->eh_timeout, jiffies + 120 * HZ);
IPS_HA_LOCK(cpu_flags);
if ((!test_bit(IPS_IN_INTR, &ha->flags)) &&
(!test_bit(IPS_IN_ABORT, &ha->flags)) &&
(!test_bit(IPS_IN_RESET, &ha->flags))) {
IPS_HA_UNLOCK(cpu_flags);
ips_next(ha, IPS_INTR_IORL);
} else {
IPS_HA_UNLOCK(cpu_flags);
}
/* If We were using the CD Boot Flash Buffer, Restore the Old Values */
if ( ips_FlashData == ha->ioctl_data ) {
......@@ -1960,20 +1884,13 @@ do_ipsintr(int irq, void *dev_id, struct pt_regs *regs) {
host = ips_sh[ha->host_num];
IPS_LOCK_SAVE(host->host_lock, cpu_flags);
if (test_and_set_bit(IPS_IN_INTR, &ha->flags)) {
IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
return ;
}
if (!ha->active) {
clear_bit(IPS_IN_INTR, &ha->flags);
IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
return;
}
(*ha->func.intr)(ha);
clear_bit(IPS_IN_INTR, &ha->flags);
IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
/* start the next command */
......@@ -1997,7 +1914,6 @@ ips_intr_copperhead(ips_ha_t *ha) {
ips_scb_t *scb;
IPS_STATUS cstatus;
int intrstatus;
unsigned long cpu_flags;
METHOD_TRACE("ips_intr", 2);
......@@ -2007,15 +1923,12 @@ ips_intr_copperhead(ips_ha_t *ha) {
if (!ha->active)
return;
IPS_HA_LOCK(cpu_flags);
intrstatus = (*ha->func.isintr)(ha);
if (!intrstatus) {
/*
* Unexpected/Shared interrupt
*/
IPS_HA_UNLOCK(cpu_flags);
return;
}
......@@ -2042,12 +1955,8 @@ ips_intr_copperhead(ips_ha_t *ha) {
* use the callback function to finish things up
* NOTE: interrupts are OFF for this
*/
IPS_HA_UNLOCK(cpu_flags);
(*scb->callback) (ha, scb);
IPS_HA_LOCK(cpu_flags);
} /* end while */
IPS_HA_UNLOCK(cpu_flags);
}
/****************************************************************************/
......@@ -2067,7 +1976,6 @@ ips_intr_morpheus(ips_ha_t *ha) {
ips_scb_t *scb;
IPS_STATUS cstatus;
int intrstatus;
unsigned long cpu_flags;
METHOD_TRACE("ips_intr_morpheus", 2);
......@@ -2077,15 +1985,12 @@ ips_intr_morpheus(ips_ha_t *ha) {
if (!ha->active)
return;
IPS_HA_LOCK(cpu_flags);
intrstatus = (*ha->func.isintr)(ha);
if (!intrstatus) {
/*
* Unexpected/Shared interrupt
*/
IPS_HA_UNLOCK(cpu_flags);
return;
}
......@@ -2118,12 +2023,8 @@ ips_intr_morpheus(ips_ha_t *ha) {
* use the callback function to finish things up
* NOTE: interrupts are OFF for this
*/
IPS_HA_UNLOCK(cpu_flags);
(*scb->callback) (ha, scb);
IPS_HA_LOCK(cpu_flags);
} /* end while */
IPS_HA_UNLOCK(cpu_flags);
}
/****************************************************************************/
......@@ -3235,8 +3136,7 @@ ips_next(ips_ha_t *ha, int intr) {
Scsi_Cmnd *q;
ips_copp_wait_item_t *item;
int ret;
unsigned long cpu_flags;
unsigned long cpu_flags2 = 0;
unsigned long cpu_flags = 0;
struct Scsi_Host *host;
METHOD_TRACE("ips_next", 1);
......@@ -3247,27 +3147,20 @@ ips_next(ips_ha_t *ha, int intr) {
* Block access to the queue function so
* this command won't time out
*/
if (intr == IPS_INTR_ON)
IPS_LOCK_SAVE(host->host_lock, cpu_flags2);
if(intr == IPS_INTR_ON)
IPS_LOCK_SAVE(host->host_lock, cpu_flags);
if ((ha->subsys->param[3] & 0x300000) && ( ha->scb_activelist.count == 0 )) {
struct timeval tv;
do_gettimeofday(&tv);
IPS_HA_LOCK(cpu_flags);
if (tv.tv_sec - ha->last_ffdc > IPS_SECS_8HOURS) {
ha->last_ffdc = tv.tv_sec;
IPS_HA_UNLOCK(cpu_flags);
ips_ffdc_time(ha);
} else {
IPS_HA_UNLOCK(cpu_flags);
}
}
if (intr == IPS_INTR_ON)
IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags2);
/*
* Send passthru commands
* These have priority over normal I/O
......@@ -3275,22 +3168,21 @@ ips_next(ips_ha_t *ha, int intr) {
* since we limit the number that can be active
* on the card at any one time
*/
IPS_HA_LOCK(cpu_flags);
IPS_QUEUE_LOCK(&ha->copp_waitlist);
while ((ha->num_ioctl < IPS_MAX_IOCTL) &&
(ha->copp_waitlist.head) &&
(scb = ips_getscb(ha))) {
IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
item = ips_removeq_copp_head(&ha->copp_waitlist);
ha->num_ioctl++;
IPS_HA_UNLOCK(cpu_flags);
if(intr == IPS_INTR_ON)
IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
scb->scsi_cmd = item->scsi_cmd;
scb->sem = item->sem;
kfree(item);
ret = ips_make_passthru(ha, scb->scsi_cmd, scb, intr);
if(intr == IPS_INTR_ON)
IPS_LOCK_SAVE(host->host_lock, cpu_flags);
switch (ret) {
case IPS_FAILURE:
if (scb->scsi_cmd) {
......@@ -3313,8 +3205,6 @@ ips_next(ips_ha_t *ha, int intr) {
} /* end case */
if (ret != IPS_SUCCESS) {
IPS_HA_LOCK(cpu_flags);
IPS_QUEUE_LOCK(&ha->copp_waitlist);
ha->num_ioctl--;
continue;
}
......@@ -3341,20 +3231,14 @@ ips_next(ips_ha_t *ha, int intr) {
break;
} /* end case */
IPS_HA_LOCK(cpu_flags);
IPS_QUEUE_LOCK(&ha->copp_waitlist);
}
IPS_QUEUE_UNLOCK(&ha->copp_waitlist);
IPS_HA_UNLOCK(cpu_flags);
/*
* Send "Normal" I/O commands
*/
IPS_HA_LOCK(cpu_flags);
IPS_QUEUE_LOCK(&ha->scb_waitlist);
p = ha->scb_waitlist.head;
IPS_QUEUE_UNLOCK(&ha->scb_waitlist);
while ((p) && (scb = ips_getscb(ha))) {
if ((p->channel > 0) && (ha->dcdb_active[p->channel-1] & (1 << p->target))) {
ips_freescb(ha, scb);
......@@ -3364,10 +3248,9 @@ ips_next(ips_ha_t *ha, int intr) {
q = p;
SC = ips_removeq_wait(&ha->scb_waitlist, q);
if (SC == NULL) /* Should never happen, but good to check anyway */
continue;
IPS_HA_UNLOCK(cpu_flags); /* Unlock HA after command is taken off queue */
if(intr == IPS_INTR_ON)
IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags); /* Unlock HA after command is taken off queue */
SC->result = DID_OK;
SC->host_scribble = NULL;
......@@ -3475,13 +3358,15 @@ ips_next(ips_ha_t *ha, int intr) {
scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
scb->dcdb.transfer_length = 0;
}
if(intr == IPS_INTR_ON)
IPS_LOCK_SAVE(host->host_lock, cpu_flags);
ret = ips_send_cmd(ha, scb);
if (ret == IPS_SUCCESS)
ips_putq_scb_head(&ha->scb_activelist, scb);
switch(ret) {
case IPS_SUCCESS:
ips_putq_scb_head(&ha->scb_activelist, scb);
break;
case IPS_FAILURE:
if (scb->scsi_cmd) {
scb->scsi_cmd->result = DID_ERROR << 16;
......@@ -3508,10 +3393,10 @@ ips_next(ips_ha_t *ha, int intr) {
p = (Scsi_Cmnd *) p->host_scribble;
IPS_HA_LOCK(cpu_flags);
} /* end while */
IPS_HA_UNLOCK(cpu_flags);
if(intr == IPS_INTR_ON)
IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
}
/****************************************************************************/
......@@ -3522,7 +3407,7 @@ ips_next(ips_ha_t *ha, int intr) {
/* */
/* Add an item to the head of the queue */
/* */
/* ASSUMED to be called from within a lock */
/* ASSUMED to be called from within the HA lock */
/* */
/****************************************************************************/
static inline void
......@@ -3532,8 +3417,6 @@ ips_putq_scb_head(ips_scb_queue_t *queue, ips_scb_t *item) {
if (!item)
return ;
IPS_QUEUE_LOCK(queue);
item->q_next = queue->head;
queue->head = item;
......@@ -3541,8 +3424,6 @@ ips_putq_scb_head(ips_scb_queue_t *queue, ips_scb_t *item) {
queue->tail = item;
queue->count++;
IPS_QUEUE_UNLOCK(queue);
}
/****************************************************************************/
......@@ -3553,7 +3434,7 @@ ips_putq_scb_head(ips_scb_queue_t *queue, ips_scb_t *item) {
/* */
/* Add an item to the tail of the queue */
/* */
/* ASSUMED to be called from within a lock */
/* ASSUMED to be called from within the HA lock */
/* */
/****************************************************************************/
static inline void
......@@ -3563,8 +3444,6 @@ ips_putq_scb_tail(ips_scb_queue_t *queue, ips_scb_t *item) {
if (!item)
return ;
IPS_QUEUE_LOCK(queue);
item->q_next = NULL;
if (queue->tail)
......@@ -3576,8 +3455,6 @@ ips_putq_scb_tail(ips_scb_queue_t *queue, ips_scb_t *item) {
queue->head = item;
queue->count++;
IPS_QUEUE_UNLOCK(queue);
}
/****************************************************************************/
......@@ -3588,7 +3465,7 @@ ips_putq_scb_tail(ips_scb_queue_t *queue, ips_scb_t *item) {
/* */
/* Remove the head of the queue */
/* */
/* ASSUMED to be called from within a lock */
/* ASSUMED to be called from within the HA lock */
/* */
/****************************************************************************/
static inline ips_scb_t *
......@@ -3597,13 +3474,9 @@ ips_removeq_scb_head(ips_scb_queue_t *queue) {
METHOD_TRACE("ips_removeq_scb_head", 1);
IPS_QUEUE_LOCK(queue);
item = queue->head;
if (!item) {
IPS_QUEUE_UNLOCK(queue);
return (NULL);
}
......@@ -3615,8 +3488,6 @@ ips_removeq_scb_head(ips_scb_queue_t *queue) {
queue->count--;
IPS_QUEUE_UNLOCK(queue);
return (item);
}
......@@ -3628,7 +3499,7 @@ ips_removeq_scb_head(ips_scb_queue_t *queue) {
/* */
/* Remove an item from a queue */
/* */
/* ASSUMED to be called from within a lock */
/* ASSUMED to be called from within the HA lock */
/* */
/****************************************************************************/
static inline ips_scb_t *
......@@ -3640,11 +3511,7 @@ ips_removeq_scb(ips_scb_queue_t *queue, ips_scb_t *item) {
if (!item)
return (NULL);
IPS_QUEUE_LOCK(queue);
if (item == queue->head) {
IPS_QUEUE_UNLOCK(queue);
return (ips_removeq_scb_head(queue));
}
......@@ -3663,13 +3530,9 @@ ips_removeq_scb(ips_scb_queue_t *queue, ips_scb_t *item) {
item->q_next = NULL;
queue->count--;
IPS_QUEUE_UNLOCK(queue);
return (item);
}
IPS_QUEUE_UNLOCK(queue);
return (NULL);
}
......@@ -3681,7 +3544,7 @@ ips_removeq_scb(ips_scb_queue_t *queue, ips_scb_t *item) {
/* */
/* Add an item to the head of the queue */
/* */
/* ASSUMED to be called from within a lock */
/* ASSUMED to be called from within the HA lock */
/* */
/****************************************************************************/
static inline void
......@@ -3691,8 +3554,6 @@ ips_putq_wait_head(ips_wait_queue_t *queue, Scsi_Cmnd *item) {
if (!item)
return ;
IPS_QUEUE_LOCK(queue);
item->host_scribble = (char *) queue->head;
queue->head = item;
......@@ -3700,8 +3561,6 @@ ips_putq_wait_head(ips_wait_queue_t *queue, Scsi_Cmnd *item) {
queue->tail = item;
queue->count++;
IPS_QUEUE_UNLOCK(queue);
}
/****************************************************************************/
......@@ -3712,7 +3571,7 @@ ips_putq_wait_head(ips_wait_queue_t *queue, Scsi_Cmnd *item) {
/* */
/* Add an item to the tail of the queue */
/* */
/* ASSUMED to be called from within a lock */
/* ASSUMED to be called from within the HA lock */
/* */
/****************************************************************************/
static inline void
......@@ -3722,8 +3581,6 @@ ips_putq_wait_tail(ips_wait_queue_t *queue, Scsi_Cmnd *item) {
if (!item)
return ;
IPS_QUEUE_LOCK(queue);
item->host_scribble = NULL;
if (queue->tail)
......@@ -3735,8 +3592,6 @@ ips_putq_wait_tail(ips_wait_queue_t *queue, Scsi_Cmnd *item) {
queue->head = item;
queue->count++;
IPS_QUEUE_UNLOCK(queue);
}
/****************************************************************************/
......@@ -3747,7 +3602,7 @@ ips_putq_wait_tail(ips_wait_queue_t *queue, Scsi_Cmnd *item) {
/* */
/* Remove the head of the queue */
/* */
/* ASSUMED to be called from within a lock */
/* ASSUMED to be called from within the HA lock */
/* */
/****************************************************************************/
static inline Scsi_Cmnd *
......@@ -3756,13 +3611,9 @@ ips_removeq_wait_head(ips_wait_queue_t *queue) {
METHOD_TRACE("ips_removeq_wait_head", 1);
IPS_QUEUE_LOCK(queue);
item = queue->head;
if (!item) {
IPS_QUEUE_UNLOCK(queue);
return (NULL);
}
......@@ -3774,8 +3625,6 @@ ips_removeq_wait_head(ips_wait_queue_t *queue) {
queue->count--;
IPS_QUEUE_UNLOCK(queue);
return (item);
}
......@@ -3787,7 +3636,7 @@ ips_removeq_wait_head(ips_wait_queue_t *queue) {
/* */
/* Remove an item from a queue */
/* */
/* ASSUMED to be called from within a lock */
/* ASSUMED to be called from within the HA lock */
/* */
/****************************************************************************/
static inline Scsi_Cmnd *
......@@ -3799,11 +3648,7 @@ ips_removeq_wait(ips_wait_queue_t *queue, Scsi_Cmnd *item) {
if (!item)
return (NULL);
IPS_QUEUE_LOCK(queue);
if (item == queue->head) {
IPS_QUEUE_UNLOCK(queue);
return (ips_removeq_wait_head(queue));
}
......@@ -3822,13 +3667,9 @@ ips_removeq_wait(ips_wait_queue_t *queue, Scsi_Cmnd *item) {
item->host_scribble = NULL;
queue->count--;
IPS_QUEUE_UNLOCK(queue);
return (item);
}
IPS_QUEUE_UNLOCK(queue);
return (NULL);
}
......@@ -3840,7 +3681,7 @@ ips_removeq_wait(ips_wait_queue_t *queue, Scsi_Cmnd *item) {
/* */
/* Add an item to the head of the queue */
/* */
/* ASSUMED to be called from within a lock */
/* ASSUMED to be called from within the HA lock */
/* */
/****************************************************************************/
static inline void
......@@ -3850,8 +3691,6 @@ ips_putq_copp_head(ips_copp_queue_t *queue, ips_copp_wait_item_t *item) {
if (!item)
return ;
IPS_QUEUE_LOCK(queue);
item->next = queue->head;
queue->head = item;
......@@ -3859,8 +3698,6 @@ ips_putq_copp_head(ips_copp_queue_t *queue, ips_copp_wait_item_t *item) {
queue->tail = item;
queue->count++;
IPS_QUEUE_UNLOCK(queue);
}
/****************************************************************************/
......@@ -3871,7 +3708,7 @@ ips_putq_copp_head(ips_copp_queue_t *queue, ips_copp_wait_item_t *item) {
/* */
/* Add an item to the tail of the queue */
/* */
/* ASSUMED to be called from within a lock */
/* ASSUMED to be called from within the HA lock */
/* */
/****************************************************************************/
static inline void
......@@ -3881,8 +3718,6 @@ ips_putq_copp_tail(ips_copp_queue_t *queue, ips_copp_wait_item_t *item) {
if (!item)
return ;
IPS_QUEUE_LOCK(queue);
item->next = NULL;
if (queue->tail)
......@@ -3894,8 +3729,6 @@ ips_putq_copp_tail(ips_copp_queue_t *queue, ips_copp_wait_item_t *item) {
queue->head = item;
queue->count++;
IPS_QUEUE_UNLOCK(queue);
}
/****************************************************************************/
......@@ -3906,7 +3739,7 @@ ips_putq_copp_tail(ips_copp_queue_t *queue, ips_copp_wait_item_t *item) {
/* */
/* Remove the head of the queue */
/* */
/* ASSUMED to be called from within a lock */
/* ASSUMED to be called from within the HA lock */
/* */
/****************************************************************************/
static inline ips_copp_wait_item_t *
......@@ -3915,13 +3748,9 @@ ips_removeq_copp_head(ips_copp_queue_t *queue) {
METHOD_TRACE("ips_removeq_copp_head", 1);
IPS_QUEUE_LOCK(queue);
item = queue->head;
if (!item) {
IPS_QUEUE_UNLOCK(queue);
return (NULL);
}
......@@ -3933,8 +3762,6 @@ ips_removeq_copp_head(ips_copp_queue_t *queue) {
queue->count--;
IPS_QUEUE_UNLOCK(queue);
return (item);
}
......@@ -3946,7 +3773,7 @@ ips_removeq_copp_head(ips_copp_queue_t *queue) {
/* */
/* Remove an item from a queue */
/* */
/* ASSUMED to be called from within a lock */
/* ASSUMED to be called from within the HA lock */
/* */
/****************************************************************************/
static inline ips_copp_wait_item_t *
......@@ -3958,11 +3785,7 @@ ips_removeq_copp(ips_copp_queue_t *queue, ips_copp_wait_item_t *item) {
if (!item)
return (NULL);
IPS_QUEUE_LOCK(queue);
if (item == queue->head) {
IPS_QUEUE_UNLOCK(queue);
return (ips_removeq_copp_head(queue));
}
......@@ -3981,13 +3804,9 @@ ips_removeq_copp(ips_copp_queue_t *queue, ips_copp_wait_item_t *item) {
item->next = NULL;
queue->count--;
IPS_QUEUE_UNLOCK(queue);
return (item);
}
IPS_QUEUE_UNLOCK(queue);
return (NULL);
}
......@@ -4051,12 +3870,11 @@ ipsintr_done(ips_ha_t *ha, ips_scb_t *scb) {
/* Routine Description: */
/* */
/* Do housekeeping on completed commands */
/* */
/* ASSUMED to be called form within the request lock */
/****************************************************************************/
static void
ips_done(ips_ha_t *ha, ips_scb_t *scb) {
int ret;
unsigned long cpu_flags;
METHOD_TRACE("ips_done", 1);
......@@ -4065,9 +3883,7 @@ ips_done(ips_ha_t *ha, ips_scb_t *scb) {
if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd))) {
ips_cleanup_passthru(ha, scb);
IPS_HA_LOCK(cpu_flags);
ha->num_ioctl--;
IPS_HA_UNLOCK(cpu_flags);
} else {
/*
* Check to see if this command had too much
......@@ -4226,9 +4042,7 @@ ips_done(ips_ha_t *ha, ips_scb_t *scb) {
} /* end if passthru */
if (scb->bus) {
IPS_HA_LOCK(cpu_flags);
ha->dcdb_active[scb->bus-1] &= ~(1 << scb->target_id);
IPS_HA_UNLOCK(cpu_flags);
}
scb->scsi_cmd->scsi_done(scb->scsi_cmd);
......@@ -4336,7 +4150,7 @@ ips_map_status(ips_ha_t *ha, ips_scb_t *scb, ips_stat_t *sp) {
(scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB_SG)) {
tapeDCDB = (IPS_DCDB_TABLE_TAPE *) &scb->dcdb;
memcpy(scb->scsi_cmd->sense_buffer, tapeDCDB->sense_info,
sizeof(tapeDCDB->sense_info));
sizeof(scb->scsi_cmd->sense_buffer));
} else {
memcpy(scb->scsi_cmd->sense_buffer, scb->dcdb.sense_info,
sizeof(scb->scsi_cmd->sense_buffer));
......@@ -4408,6 +4222,7 @@ ips_send_cmd(ips_ha_t *ha, ips_scb_t *scb) {
char *sp;
int device_error;
IPS_DCDB_TABLE_TAPE *tapeDCDB;
int TimeOut;
METHOD_TRACE("ips_send_cmd", 1);
......@@ -4478,8 +4293,10 @@ ips_send_cmd(ips_ha_t *ha, ips_scb_t *scb) {
scb->cmd.logical_info.reserved = 0;
scb->cmd.logical_info.reserved2 = 0;
scb->data_len = sizeof(ha->adapt->logical_drive_info);
scb->data_busaddr = ha->adapt->hw_status_start + sizeof(IPS_ADAPTER)
- sizeof(IPS_LD_INFO);
scb->data_busaddr = pci_map_single(ha->pcidev,
&ha->adapt->logical_drive_info,
scb->data_len, IPS_DMA_DIR(scb));
scb->flags |= IPS_SCB_MAP_SINGLE;
scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
ret = IPS_SUCCESS;
}
......@@ -4586,8 +4403,10 @@ ips_send_cmd(ips_ha_t *ha, ips_scb_t *scb) {
scb->cmd.logical_info.reserved2 = 0;
scb->cmd.logical_info.reserved3 = 0;
scb->data_len = sizeof(ha->adapt->logical_drive_info);
scb->data_busaddr = ha->adapt->hw_status_start + sizeof(IPS_ADAPTER)
- sizeof(IPS_LD_INFO);
scb->data_busaddr = pci_map_single(ha->pcidev,
&ha->adapt->logical_drive_info,
scb->data_len, IPS_DMA_DIR(scb));
scb->flags |= IPS_SCB_MAP_SINGLE;
scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
ret = IPS_SUCCESS;
break;
......@@ -4648,6 +4467,8 @@ ips_send_cmd(ips_ha_t *ha, ips_scb_t *scb) {
scb->cmd.dcdb.reserved2 = 0;
scb->cmd.dcdb.reserved3 = 0;
TimeOut = scb->scsi_cmd->timeout_per_command;
if (ha->subsys->param[4] & 0x00100000) { /* If NEW Tape DCDB is Supported */
if (!scb->sg_len)
scb->cmd.dcdb.op_code = IPS_CMD_EXTENDED_DCDB;
......@@ -4657,47 +4478,52 @@ ips_send_cmd(ips_ha_t *ha, ips_scb_t *scb) {
tapeDCDB = (IPS_DCDB_TABLE_TAPE *) &scb->dcdb; /* Use Same Data Area as Old DCDB Struct */
tapeDCDB->device_address = ((scb->bus - 1) << 4) | scb->target_id;
tapeDCDB->cmd_attribute |= IPS_DISCONNECT_ALLOWED;
tapeDCDB->cmd_attribute &= ~IPS_TRANSFER64K; /* Always Turn OFF 64K Size Flag */
if (scb->timeout) {
if (scb->timeout <= 10)
tapeDCDB->cmd_attribute |= IPS_TIMEOUT10;
else if (scb->timeout <= 60)
tapeDCDB->cmd_attribute |= IPS_TIMEOUT60;
else
tapeDCDB->cmd_attribute |= IPS_TIMEOUT20M;
if (TimeOut) {
if (TimeOut < ( 10 * HZ ))
tapeDCDB->cmd_attribute |= IPS_TIMEOUT10; /* TimeOut is 10 Seconds */
else if (TimeOut < (60 * HZ))
tapeDCDB->cmd_attribute |= IPS_TIMEOUT60; /* TimeOut is 60 Seconds */
else if (TimeOut < (1200 * HZ))
tapeDCDB->cmd_attribute |= IPS_TIMEOUT20M; /* TimeOut is 20 Minutes */
}
if (!(tapeDCDB->cmd_attribute & IPS_TIMEOUT20M))
tapeDCDB->cmd_attribute |= IPS_TIMEOUT20M;
tapeDCDB->sense_length = sizeof(tapeDCDB->sense_info);
tapeDCDB->cdb_length = scb->scsi_cmd->cmd_len;
tapeDCDB->reserved_for_LUN = 0;
tapeDCDB->transfer_length = scb->data_len;
tapeDCDB->buffer_pointer = cpu_to_le32(scb->data_busaddr);
tapeDCDB->sg_count = scb->sg_len;
tapeDCDB->cdb_length = scb->scsi_cmd->cmd_len;
tapeDCDB->sense_length = sizeof(tapeDCDB->sense_info);
tapeDCDB->scsi_status = 0;
tapeDCDB->reserved = 0;
memcpy(tapeDCDB->scsi_cdb, scb->scsi_cmd->cmnd, scb->scsi_cmd->cmd_len);
} else {
scb->dcdb.device_address = ((scb->bus - 1) << 4) | scb->target_id;
scb->dcdb.cmd_attribute |= IPS_DISCONNECT_ALLOWED;
if (scb->timeout) {
if (scb->timeout <= 10)
scb->dcdb.cmd_attribute |= IPS_TIMEOUT10;
else if (scb->timeout <= 60)
scb->dcdb.cmd_attribute |= IPS_TIMEOUT60;
else
scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;
if (TimeOut) {
if (TimeOut < (10 * HZ))
scb->dcdb.cmd_attribute |= IPS_TIMEOUT10; /* TimeOut is 10 Seconds */
else if (TimeOut < (60 * HZ))
scb->dcdb.cmd_attribute |= IPS_TIMEOUT60; /* TimeOut is 60 Seconds */
else if (TimeOut < (1200 * HZ))
scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M; /* TimeOut is 20 Minutes */
}
if (!(scb->dcdb.cmd_attribute & IPS_TIMEOUT20M))
scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;
scb->dcdb.sense_length = sizeof(scb->dcdb.sense_info);
scb->dcdb.transfer_length = scb->data_len;
if ( scb->dcdb.cmd_attribute & IPS_TRANSFER64K )
scb->dcdb.transfer_length = 0;
scb->dcdb.buffer_pointer = cpu_to_le32(scb->data_busaddr);
scb->dcdb.sg_count = scb->sg_len;
scb->dcdb.cdb_length = scb->scsi_cmd->cmd_len;
scb->dcdb.sense_length = sizeof(scb->dcdb.sense_info);
scb->dcdb.sg_count = scb->sg_len;
scb->dcdb.reserved = 0;
memcpy(scb->dcdb.scsi_cdb, scb->scsi_cmd->cmnd, scb->scsi_cmd->cmd_len);
scb->dcdb.scsi_status = 0;
scb->dcdb.reserved2[0] = 0;
scb->dcdb.reserved2[1] = 0;
scb->dcdb.reserved2[2] = 0;
}
}
......@@ -4711,7 +4537,7 @@ ips_send_cmd(ips_ha_t *ha, ips_scb_t *scb) {
/* Routine Description: */
/* */
/* Check the status of commands to logical drives */
/* */
/* Assumed to be called with the HA lock */
/****************************************************************************/
static void
ips_chkstatus(ips_ha_t *ha, IPS_STATUS *pstatus) {
......@@ -5240,13 +5066,10 @@ ips_init_scb(ips_ha_t *ha, ips_scb_t *scb) {
static ips_scb_t *
ips_getscb(ips_ha_t *ha) {
ips_scb_t *scb;
unsigned long cpu_flags;
METHOD_TRACE("ips_getscb", 1);
IPS_SCB_LOCK(cpu_flags);
if ((scb = ha->scb_freelist) == NULL) {
IPS_SCB_UNLOCK(cpu_flags);
return (NULL);
}
......@@ -5254,8 +5077,6 @@ ips_getscb(ips_ha_t *ha) {
ha->scb_freelist = scb->q_next;
scb->q_next = NULL;
IPS_SCB_UNLOCK(cpu_flags);
ips_init_scb(ha, scb);
return (scb);
......@@ -5274,7 +5095,6 @@ ips_getscb(ips_ha_t *ha) {
/****************************************************************************/
static void
ips_freescb(ips_ha_t *ha, ips_scb_t *scb) {
unsigned long cpu_flags;
METHOD_TRACE("ips_freescb", 1);
if(scb->flags & IPS_SCB_MAP_SG)
......@@ -5287,10 +5107,8 @@ ips_freescb(ips_ha_t *ha, ips_scb_t *scb) {
/* check to make sure this is not our "special" scb */
if (IPS_COMMAND_ID(ha, scb) < (ha->max_cmds - 1)) {
IPS_SCB_LOCK(cpu_flags);
scb->q_next = ha->scb_freelist;
ha->scb_freelist = scb;
IPS_SCB_UNLOCK(cpu_flags);
}
}
......@@ -5702,15 +5520,12 @@ ips_init_morpheus(ips_ha_t *ha) {
static int
ips_reset_copperhead(ips_ha_t *ha) {
int reset_counter;
unsigned long cpu_flags;
METHOD_TRACE("ips_reset_copperhead", 1);
DEBUG_VAR(1, "(%s%d) ips_reset_copperhead: io addr: %x, irq: %d",
ips_name, ha->host_num, ha->io_addr, ha->irq);
IPS_HA_LOCK(cpu_flags);
reset_counter = 0;
while (reset_counter < 2) {
......@@ -5729,14 +5544,11 @@ ips_reset_copperhead(ips_ha_t *ha) {
if ((*ha->func.init)(ha))
break;
else if (reset_counter >= 2) {
IPS_HA_UNLOCK(cpu_flags);
return (0);
}
}
IPS_HA_UNLOCK(cpu_flags);
return (1);
}
......@@ -5752,15 +5564,12 @@ ips_reset_copperhead(ips_ha_t *ha) {
static int
ips_reset_copperhead_memio(ips_ha_t *ha) {
int reset_counter;
unsigned long cpu_flags;
METHOD_TRACE("ips_reset_copperhead_memio", 1);
DEBUG_VAR(1, "(%s%d) ips_reset_copperhead_memio: mem addr: %x, irq: %d",
ips_name, ha->host_num, ha->mem_addr, ha->irq);
IPS_HA_LOCK(cpu_flags);
reset_counter = 0;
while (reset_counter < 2) {
......@@ -5779,14 +5588,11 @@ ips_reset_copperhead_memio(ips_ha_t *ha) {
if ((*ha->func.init)(ha))
break;
else if (reset_counter >= 2) {
IPS_HA_UNLOCK(cpu_flags);
return (0);
}
}
IPS_HA_UNLOCK(cpu_flags);
return (1);
}
......@@ -5803,15 +5609,12 @@ static int
ips_reset_morpheus(ips_ha_t *ha) {
int reset_counter;
uint8_t junk;
unsigned long cpu_flags;
METHOD_TRACE("ips_reset_morpheus", 1);
DEBUG_VAR(1, "(%s%d) ips_reset_morpheus: mem addr: %x, irq: %d",
ips_name, ha->host_num, ha->mem_addr, ha->irq);
IPS_HA_LOCK(cpu_flags);
reset_counter = 0;
while (reset_counter < 2) {
......@@ -5828,14 +5631,11 @@ ips_reset_morpheus(ips_ha_t *ha) {
if ((*ha->func.init)(ha))
break;
else if (reset_counter >= 2) {
IPS_HA_UNLOCK(cpu_flags);
return (0);
}
}
IPS_HA_UNLOCK(cpu_flags);
return (1);
}
......@@ -5980,7 +5780,6 @@ static int
ips_issue_copperhead(ips_ha_t *ha, ips_scb_t *scb) {
uint32_t TimeOut;
uint32_t val;
unsigned long cpu_flags;
METHOD_TRACE("ips_issue_copperhead", 1);
......@@ -6000,8 +5799,6 @@ ips_issue_copperhead(ips_ha_t *ha, ips_scb_t *scb) {
scb->cmd.basic_io.command_id);
}
IPS_HA_LOCK(cpu_flags);
TimeOut = 0;
while ((val = le32_to_cpu(inl(ha->io_addr + IPS_REG_CCCR))) & IPS_BIT_SEM) {
......@@ -6016,8 +5813,6 @@ ips_issue_copperhead(ips_ha_t *ha, ips_scb_t *scb) {
printk(KERN_WARNING "(%s%d) ips_issue semaphore chk timeout.\n",
ips_name, ha->host_num);
IPS_HA_UNLOCK(cpu_flags);
return (IPS_FAILURE);
} /* end if */
} /* end while */
......@@ -6025,8 +5820,6 @@ ips_issue_copperhead(ips_ha_t *ha, ips_scb_t *scb) {
outl(cpu_to_le32(scb->scb_busaddr), ha->io_addr + IPS_REG_CCSAR);
outw(cpu_to_le32(IPS_BIT_START_CMD), ha->io_addr + IPS_REG_CCCR);
IPS_HA_UNLOCK(cpu_flags);
return (IPS_SUCCESS);
}
......@@ -6043,7 +5836,6 @@ static int
ips_issue_copperhead_memio(ips_ha_t *ha, ips_scb_t *scb) {
uint32_t TimeOut;
uint32_t val;
unsigned long cpu_flags;
METHOD_TRACE("ips_issue_copperhead_memio", 1);
......@@ -6063,8 +5855,6 @@ ips_issue_copperhead_memio(ips_ha_t *ha, ips_scb_t *scb) {
scb->cmd.basic_io.command_id);
}
IPS_HA_LOCK(cpu_flags);
TimeOut = 0;
while ((val = readl(ha->mem_ptr + IPS_REG_CCCR)) & IPS_BIT_SEM) {
......@@ -6079,8 +5869,6 @@ ips_issue_copperhead_memio(ips_ha_t *ha, ips_scb_t *scb) {
printk(KERN_WARNING "(%s%d) ips_issue semaphore chk timeout.\n",
ips_name, ha->host_num);
IPS_HA_UNLOCK(cpu_flags);
return (IPS_FAILURE);
} /* end if */
} /* end while */
......@@ -6088,8 +5876,6 @@ ips_issue_copperhead_memio(ips_ha_t *ha, ips_scb_t *scb) {
writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_CCSAR);
writel(IPS_BIT_START_CMD, ha->mem_ptr + IPS_REG_CCCR);
IPS_HA_UNLOCK(cpu_flags);
return (IPS_SUCCESS);
}
......@@ -6104,7 +5890,6 @@ ips_issue_copperhead_memio(ips_ha_t *ha, ips_scb_t *scb) {
/****************************************************************************/
static int
ips_issue_i2o(ips_ha_t *ha, ips_scb_t *scb) {
unsigned long cpu_flags;
METHOD_TRACE("ips_issue_i2o", 1);
......@@ -6124,12 +5909,8 @@ ips_issue_i2o(ips_ha_t *ha, ips_scb_t *scb) {
scb->cmd.basic_io.command_id);
}
IPS_HA_LOCK(cpu_flags);
outl(cpu_to_le32(scb->scb_busaddr), ha->io_addr + IPS_REG_I2O_INMSGQ);
IPS_HA_UNLOCK(cpu_flags);
return (IPS_SUCCESS);
}
......@@ -6144,7 +5925,6 @@ ips_issue_i2o(ips_ha_t *ha, ips_scb_t *scb) {
/****************************************************************************/
static int
ips_issue_i2o_memio(ips_ha_t *ha, ips_scb_t *scb) {
unsigned long cpu_flags;
METHOD_TRACE("ips_issue_i2o_memio", 1);
......@@ -6164,12 +5944,8 @@ ips_issue_i2o_memio(ips_ha_t *ha, ips_scb_t *scb) {
scb->cmd.basic_io.command_id);
}
IPS_HA_LOCK(cpu_flags);
writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_I2O_INMSGQ);
IPS_HA_UNLOCK(cpu_flags);
return (IPS_SUCCESS);
}
......@@ -6306,12 +6082,7 @@ ips_wait(ips_ha_t *ha, int time, int intr) {
* until after we finish.
*/
while (test_and_set_bit(IPS_IN_INTR, &ha->flags))
udelay(1000);
(*ha->func.intr)(ha);
clear_bit(IPS_IN_INTR, &ha->flags);
}
/* This looks like a very evil loop, but it only does this during start-up */
......@@ -7394,6 +7165,14 @@ static Scsi_Host_Template driver_template = IPS;
#include "scsi_module.c"
#endif
static int ips_abort_init(ips_ha_t *ha, struct Scsi_Host *sh, int index){
ha->active = 0;
ips_free(ha);
scsi_unregister(sh);
ips_ha[index] = 0;
ips_sh[index] = 0;
return -1;
}
#if LINUX_VERSION_CODE >= LinuxVersionCode(2,4,0)
......@@ -7568,14 +7347,6 @@ static int ips_init_phase1( struct pci_dev *pci_dev, int *indexPtr )
ha = IPS_HA(sh);
memset(ha, 0, sizeof(ips_ha_t));
/* Initialize spin lock */
spin_lock_init(&ha->scb_lock);
spin_lock_init(&ha->copp_lock);
spin_lock_init(&ha->ips_lock);
spin_lock_init(&ha->copp_waitlist.lock);
spin_lock_init(&ha->scb_waitlist.lock);
spin_lock_init(&ha->scb_activelist.lock);
ips_sh[index] = sh;
ips_ha[index] = ha;
ha->active = 1;
......@@ -7584,24 +7355,14 @@ static int ips_init_phase1( struct pci_dev *pci_dev, int *indexPtr )
if (!ha->enq) {
printk(KERN_WARNING "Unable to allocate host inquiry structure\n" );
ha->active = 0;
ips_free(ha);
scsi_unregister(sh);
ips_ha[index] = 0;
ips_sh[index] = 0;
return -1;
return ips_abort_init(ha, sh, index);
}
ha->adapt = pci_alloc_consistent(ha->pcidev, sizeof(IPS_ADAPTER) +
sizeof(IPS_IO_CMD), &dma_address);
if (!ha->adapt) {
printk(KERN_WARNING "Unable to allocate host adapt & dummy structures\n");
ha->active = 0;
ips_free(ha);
scsi_unregister(sh);
ips_ha[index] = 0;
ips_sh[index] = 0;
return -1;
return ips_abort_init(ha, sh, index);
}
ha->adapt->hw_status_start = dma_address;
ha->dummy = (void *)(ha->adapt + 1);
......@@ -7610,36 +7371,21 @@ static int ips_init_phase1( struct pci_dev *pci_dev, int *indexPtr )
if (!ha->conf) {
printk(KERN_WARNING "Unable to allocate host conf structure\n" );
ha->active = 0;
ips_free(ha);
scsi_unregister(sh);
ips_ha[index] = 0;
ips_sh[index] = 0;
return -1;
return ips_abort_init(ha, sh, index);
}
ha->nvram = kmalloc(sizeof(IPS_NVRAM_P5), GFP_KERNEL);
if (!ha->nvram) {
printk(KERN_WARNING "Unable to allocate host NVRAM structure\n" );
ha->active = 0;
ips_free(ha);
scsi_unregister(sh);
ips_ha[index] = 0;
ips_sh[index] = 0;
return -1;
return ips_abort_init(ha, sh, index);
}
ha->subsys = kmalloc(sizeof(IPS_SUBSYS), GFP_KERNEL);
if (!ha->subsys) {
printk(KERN_WARNING "Unable to allocate host subsystem structure\n" );
ha->active = 0;
ips_free(ha);
scsi_unregister(sh);
ips_ha[index] = 0;
ips_sh[index] = 0;
return -1;
return ips_abort_init(ha, sh, index);
}
for (count = PAGE_SIZE, ha->ioctl_order = 0;
......@@ -7748,24 +7494,14 @@ static int ips_init_phase1( struct pci_dev *pci_dev, int *indexPtr )
* Initialization failed
*/
printk(KERN_WARNING "Unable to initialize controller\n" );
ha->active = 0;
ips_free(ha);
scsi_unregister(sh);
ips_ha[index] = 0;
ips_sh[index] = 0;
return -1;
return ips_abort_init(ha, sh, index);
}
}
/* Install the interrupt handler */
if (request_irq(irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) {
printk(KERN_WARNING "Unable to install interrupt handler\n" );
ha->active = 0;
ips_free(ha);
scsi_unregister(sh);
ips_ha[index] = 0;
ips_sh[index] = 0;
return -1;
return ips_abort_init(ha, sh, index);
}
/*
......@@ -7774,13 +7510,8 @@ static int ips_init_phase1( struct pci_dev *pci_dev, int *indexPtr )
ha->max_cmds = 1;
if (!ips_allocatescbs(ha)) {
printk(KERN_WARNING "Unable to allocate a CCB\n" );
ha->active = 0;
free_irq(ha->irq, ha);
ips_free(ha);
scsi_unregister(sh);
ips_ha[index] = 0;
ips_sh[index] = 0;
return -1;
return ips_abort_init(ha, sh, index);
}
*indexPtr = index;
......@@ -7816,13 +7547,8 @@ static int ips_init_phase2( int index )
if (!ips_hainit(ha)) {
printk(KERN_WARNING "Unable to initialize controller\n" );
ha->active = 0;
ips_free(ha);
free_irq(ha->irq, ha);
scsi_unregister(sh);
ips_ha[index] = NULL;
ips_sh[index] = NULL;
return -1;
return ips_abort_init(ha, sh, index);
}
/* Free the temporary SCB */
ips_deallocatescbs(ha, 1);
......@@ -7830,13 +7556,8 @@ static int ips_init_phase2( int index )
/* allocate CCBs */
if (!ips_allocatescbs(ha)) {
printk(KERN_WARNING "Unable to allocate CCBs\n" );
ha->active = 0;
ips_free(ha);
free_irq(ha->irq, ha);
scsi_unregister(sh);
ips_ha[index] = NULL;
ips_sh[index] = NULL;
return -1;
return ips_abort_init(ha, sh, index);
}
/* finish setting values */
......
drivers/scsi/ips.h
View file @ 994b3fb0
/*****************************************************************************/
/* ips.h -- driver for the IBM ServeRAID controller */
/* ips.h -- driver for the Adaptec / IBM ServeRAID controller */
/* */
/* Written By: Keith Mitchell, IBM Corporation */
/* Jack Hammer, Adaptec, Inc. */
/* David Jeffery, Adaptec, Inc. */
/* */
/* Copyright (C) 1999 IBM Corporation */
/* Copyright (C) 2003 Adaptec, Inc. */
/* */
/* 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 */
......@@ -40,7 +43,7 @@
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/* */
/* Bugs/Comments/Suggestions should be mailed to: */
/* ipslinux@us.ibm.com */
/* ipslinux@adaptec.com */
/* */
/*****************************************************************************/
......@@ -84,32 +87,10 @@
((IPS_IS_TROMBONE(ha) || IPS_IS_CLARINET(ha)) && \
(ips_force_memio))) ? 1 : 0)
#ifndef VIRT_TO_BUS
#define VIRT_TO_BUS(x) (uint32_t) virt_to_bus((void *) x)
#endif
#ifndef MDELAY
#define MDELAY mdelay
#endif
#ifndef verify_area_20
#define verify_area_20(t,a,sz) (0) /* success */
#endif
#ifndef DECLARE_MUTEX_LOCKED
#define DECLARE_MUTEX_LOCKED(sem) struct semaphore sem = MUTEX_LOCKED;
#endif
/*
* Lock macros
*/
#define IPS_SCB_LOCK(cpu_flags) spin_lock_irqsave(&ha->scb_lock, cpu_flags)
#define IPS_SCB_UNLOCK(cpu_flags) spin_unlock_irqrestore(&ha->scb_lock, cpu_flags)
#define IPS_QUEUE_LOCK(queue) spin_lock_irqsave(&(queue)->lock, (queue)->cpu_flags)
#define IPS_QUEUE_UNLOCK(queue) spin_unlock_irqrestore(&(queue)->lock, (queue)->cpu_flags)
#define IPS_HA_LOCK(cpu_flags) spin_lock_irqsave(&ha->ips_lock, cpu_flags)
#define IPS_HA_UNLOCK(cpu_flags) spin_unlock_irqrestore(&ha->ips_lock, cpu_flags)
/*
* Adapter address map equates
*/
......@@ -1063,8 +1044,6 @@ typedef struct ips_scb_queue {
struct ips_scb *head;
struct ips_scb *tail;
int count;
unsigned long cpu_flags;
spinlock_t lock;
} ips_scb_queue_t;
/*
......@@ -1074,13 +1053,10 @@ typedef struct ips_wait_queue {
Scsi_Cmnd *head;
Scsi_Cmnd *tail;
int count;
unsigned long cpu_flags;
spinlock_t lock;
} ips_wait_queue_t;
typedef struct ips_copp_wait_item {
Scsi_Cmnd *scsi_cmd;
struct semaphore *sem;
struct ips_copp_wait_item *next;
} ips_copp_wait_item_t;
......@@ -1088,8 +1064,6 @@ typedef struct ips_copp_queue {
struct ips_copp_wait_item *head;
struct ips_copp_wait_item *tail;
int count;
unsigned long cpu_flags;
spinlock_t lock;
} ips_copp_queue_t;
/* forward decl for host structure */
......@@ -1138,7 +1112,6 @@ typedef struct ips_ha {
char *ioctl_data; /* IOCTL data area */
uint32_t ioctl_datasize; /* IOCTL data size */
uint32_t cmd_in_progress; /* Current command in progress*/
unsigned long flags; /* HA flags */
uint8_t waitflag; /* are we waiting for cmd */
uint8_t active;
int ioctl_reset; /* IOCTL Requested Reset Flag */
......@@ -1158,11 +1131,6 @@ typedef struct ips_ha {
char *ioremap_ptr; /* ioremapped memory pointer */
ips_hw_func_t func; /* hw function pointers */
struct pci_dev *pcidev; /* PCI device handle */
spinlock_t scb_lock;
spinlock_t copp_lock;
spinlock_t ips_lock;
struct semaphore ioctl_sem; /* Semaphore for new IOCTL's */
struct semaphore flash_ioctl_sem; /* Semaphore for Flashing */
char *flash_data; /* Save Area for flash data */
u8 flash_order; /* Save Area for flash size order */
u32 flash_datasize; /* Save Area for flash data size */
......@@ -1195,7 +1163,6 @@ typedef struct ips_scb {
Scsi_Cmnd *scsi_cmd;
struct ips_scb *q_next;
ips_scb_callback callback;
struct semaphore *sem;
uint32_t sg_busaddr;
int sg_count;
} ips_scb_t;
......
drivers/scsi/wd7000.c
View file @ 994b3fb0
......@@ -244,15 +244,13 @@ typedef struct adapter {
/*
* (linear) base address for ROM BIOS
*/
static const long wd7000_biosaddr[] =
{
static const long wd7000_biosaddr[] = {
0xc0000, 0xc2000, 0xc4000, 0xc6000, 0xc8000, 0xca000, 0xcc000, 0xce000,
0xd0000, 0xd2000, 0xd4000, 0xd6000, 0xd8000, 0xda000, 0xdc000, 0xde000
};
#define NUM_ADDRS (sizeof(wd7000_biosaddr)/sizeof(long))
static const unsigned short wd7000_iobase[] =
{
static const unsigned short wd7000_iobase[] = {
0x0300, 0x0308, 0x0310, 0x0318, 0x0320, 0x0328, 0x0330, 0x0338,
0x0340, 0x0348, 0x0350, 0x0358, 0x0360, 0x0368, 0x0370, 0x0378,
0x0380, 0x0388, 0x0390, 0x0398, 0x03a0, 0x03a8, 0x03b0, 0x03b8,
......@@ -294,12 +292,11 @@ typedef struct {
/*
* Add here your configuration...
*/
static Config configs[] =
{
{ 15, 6, 0x350, BUS_ON, BUS_OFF }, /* defaults for single adapter */
{ 11, 5, 0x320, BUS_ON, BUS_OFF }, /* defaults for second adapter */
{ 7, 6, 0x350, BUS_ON, BUS_OFF }, /* My configuration (Zaga) */
{ -1, -1, 0x0, BUS_ON, BUS_OFF } /* Empty slot */
static Config configs[] = {
{15, 6, 0x350, BUS_ON, BUS_OFF}, /* defaults for single adapter */
{11, 5, 0x320, BUS_ON, BUS_OFF}, /* defaults for second adapter */
{7, 6, 0x350, BUS_ON, BUS_OFF}, /* My configuration (Zaga) */
{-1, -1, 0x0, BUS_ON, BUS_OFF} /* Empty slot */
};
#define NUM_CONFIGS (sizeof(configs)/sizeof(Config))
......@@ -314,8 +311,7 @@ typedef struct signature {
unsigned len; /* length of string */
} Signature;
static const Signature signatures[] =
{
static const Signature signatures[] = {
{"SSTBIOS", 0x0000d, 7} /* "SSTBIOS" @ offset 0x0000d */
};
#define NUM_SIGNATURES (sizeof(signatures)/sizeof(Signature))
......@@ -594,14 +590,11 @@ static spinlock_t scbpool_lock; /* guards the scb free list and count */
static void __init setup_error(char *mesg, int *ints)
{
if (ints[0] == 3)
printk(KERN_ERR "wd7000_setup: \"wd7000=%d,%d,0x%x\" -> %s\n",
ints[1], ints[2], ints[3], mesg);
printk(KERN_ERR "wd7000_setup: \"wd7000=%d,%d,0x%x\" -> %s\n", ints[1], ints[2], ints[3], mesg);
else if (ints[0] == 4)
printk(KERN_ERR "wd7000_setup: \"wd7000=%d,%d,0x%x,%d\" -> %s\n",
ints[1], ints[2], ints[3], ints[4], mesg);
printk(KERN_ERR "wd7000_setup: \"wd7000=%d,%d,0x%x,%d\" -> %s\n", ints[1], ints[2], ints[3], ints[4], mesg);
else
printk(KERN_ERR "wd7000_setup: \"wd7000=%d,%d,0x%x,%d,%d\" -> %s\n",
ints[1], ints[2], ints[3], ints[4], ints[5], mesg);
printk(KERN_ERR "wd7000_setup: \"wd7000=%d,%d,0x%x,%d,%d\" -> %s\n", ints[1], ints[2], ints[3], ints[4], ints[5], mesg);
}
......@@ -625,19 +618,15 @@ static int __init wd7000_setup(char *str)
short i;
int ints[6];
(void)get_options(str, ARRAY_SIZE(ints), ints);
(void) get_options(str, ARRAY_SIZE(ints), ints);
if (wd7000_card_num >= NUM_CONFIGS) {
printk(KERN_ERR
"%s: Too many \"wd7000=\" configurations in "
"command line!\n", __FUNCTION__);
printk(KERN_ERR "%s: Too many \"wd7000=\" configurations in " "command line!\n", __FUNCTION__);
return 0;
}
if ((ints[0] < 3) || (ints[0] > 5)) {
printk(KERN_ERR "%s: Error in command line! "
"Usage: wd7000=<IRQ>,<DMA>,IO>[,<BUS_ON>"
"[,<BUS_OFF>]]\n", __FUNCTION__);
printk(KERN_ERR "%s: Error in command line! " "Usage: wd7000=<IRQ>,<DMA>,IO>[,<BUS_ON>" "[,<BUS_OFF>]]\n", __FUNCTION__);
} else {
for (i = 0; i < NUM_IRQS; i++)
if (ints[1] == wd7000_irq[i])
......@@ -671,8 +660,7 @@ static int __init wd7000_setup(char *str)
if (ints[0] > 3) {
if ((ints[4] < 500) || (ints[4] > 31875)) {
setup_error("BUS_ON value is out of range (500"
" to 31875 nanoseconds)!", ints);
setup_error("BUS_ON value is out of range (500" " to 31875 nanoseconds)!", ints);
configs[wd7000_card_num].bus_on = BUS_ON;
} else
configs[wd7000_card_num].bus_on = ints[4] / 125;
......@@ -681,12 +669,10 @@ static int __init wd7000_setup(char *str)
if (ints[0] > 4) {
if ((ints[5] < 500) || (ints[5] > 31875)) {
setup_error("BUS_OFF value is out of range (500"
" to 31875 nanoseconds)!", ints);
setup_error("BUS_OFF value is out of range (500" " to 31875 nanoseconds)!", ints);
configs[wd7000_card_num].bus_off = BUS_OFF;
} else
configs[wd7000_card_num].bus_off = ints[5] /
125;
configs[wd7000_card_num].bus_off = ints[5] / 125;
} else
configs[wd7000_card_num].bus_off = BUS_OFF;
......@@ -696,32 +682,22 @@ static int __init wd7000_setup(char *str)
for (; j < wd7000_card_num; j++)
if (configs[i].irq == configs[j].irq) {
setup_error("duplicated IRQ!",
ints);
setup_error("duplicated IRQ!", ints);
return 0;
}
if (configs[i].dma == configs[j].dma) {
setup_error("duplicated DMA "
"channel!", ints);
setup_error("duplicated DMA " "channel!", ints);
return 0;
}
if (configs[i].iobase ==
configs[j].iobase) {
setup_error("duplicated I/O "
"base address!",
ints);
if (configs[i].iobase == configs[j].iobase) {
setup_error("duplicated I/O " "base address!", ints);
return 0;
}
}
}
dprintk(KERN_DEBUG "wd7000_setup: IRQ=%d, DMA=%d, I/O=0x%x, "
"BUS_ON=%dns, BUS_OFF=%dns\n",
configs[wd7000_card_num].irq,
configs[wd7000_card_num].dma,
configs[wd7000_card_num].iobase,
configs[wd7000_card_num].bus_on * 125,
configs[wd7000_card_num].bus_off * 125);
"BUS_ON=%dns, BUS_OFF=%dns\n", configs[wd7000_card_num].irq, configs[wd7000_card_num].dma, configs[wd7000_card_num].iobase, configs[wd7000_card_num].bus_on * 125, configs[wd7000_card_num].bus_off * 125);
wd7000_card_num++;
}
......@@ -741,11 +717,11 @@ __setup("wd7000=", wd7000_setup);
*/
typedef union { /* let's cheat... */
int i;
unchar u[sizeof (int)]; /* the sizeof(int) makes it more portable */
unchar u[sizeof(int)]; /* the sizeof(int) makes it more portable */
} i_u;
static inline void any2scsi (unchar * scsi, int any)
static inline void any2scsi(unchar * scsi, int any)
{
*scsi++ = ((i_u) any).u[2];
*scsi++ = ((i_u) any).u[1];
......@@ -753,7 +729,7 @@ static inline void any2scsi (unchar * scsi, int any)
}
static inline int scsi2int (unchar * scsi)
static inline int scsi2int(unchar * scsi)
{
i_u result;
......@@ -780,22 +756,22 @@ static inline int scsi2int (unchar * scsi)
#endif
static inline void wd7000_enable_intr (Adapter *host)
static inline void wd7000_enable_intr(Adapter * host)
{
host->control |= INT_EN;
outb (host->control, host->iobase + ASC_CONTROL);
outb(host->control, host->iobase + ASC_CONTROL);
}
static inline void wd7000_enable_dma (Adapter *host)
static inline void wd7000_enable_dma(Adapter * host)
{
unsigned long flags;
host->control |= DMA_EN;
outb (host->control, host->iobase + ASC_CONTROL);
outb(host->control, host->iobase + ASC_CONTROL);
flags = claim_dma_lock();
set_dma_mode (host->dma, DMA_MODE_CASCADE);
enable_dma (host->dma);
set_dma_mode(host->dma, DMA_MODE_CASCADE);
enable_dma(host->dma);
release_dma_lock(flags);
}
......@@ -803,13 +779,13 @@ static inline void wd7000_enable_dma (Adapter *host)
#define WAITnexttimeout 200 /* 2 seconds */
static inline short WAIT (unsigned port, unsigned mask, unsigned allof, unsigned noneof)
static inline short WAIT(unsigned port, unsigned mask, unsigned allof, unsigned noneof)
{
register unsigned WAITbits;
register unsigned long WAITtimeout = jiffies + WAITnexttimeout;
while (time_before_eq(jiffies, WAITtimeout)) {
WAITbits = inb (port) & mask;
WAITbits = inb(port) & mask;
if (((WAITbits & allof) == allof) && ((WAITbits & noneof) == 0))
return (0);
......@@ -819,14 +795,14 @@ static inline short WAIT (unsigned port, unsigned mask, unsigned allof, unsigned
}
static inline int command_out (Adapter * host, unchar * cmd, int len)
static inline int command_out(Adapter * host, unchar * cmd, int len)
{
if (!WAIT (host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) {
if (!WAIT(host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) {
while (len--) {
do {
outb (*cmd, host->iobase + ASC_COMMAND);
WAIT (host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0);
} while (inb (host->iobase + ASC_STAT) & CMD_REJ);
outb(*cmd, host->iobase + ASC_COMMAND);
WAIT(host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0);
} while (inb(host->iobase + ASC_STAT) & CMD_REJ);
cmd++;
}
......@@ -863,12 +839,12 @@ static inline Scb *alloc_scbs(struct Scsi_Host *host, int needed)
spin_unlock_irq(host->host_lock);
retry:
retry:
while (freescbs < needed) {
timeout = jiffies + WAITnexttimeout;
do {
/* FIXME: can we actually just yield here ?? */
for (now = jiffies; now == jiffies; )
for (now = jiffies; now == jiffies;)
cpu_relax(); /* wait a jiffy */
} while (freescbs < needed && time_before_eq(jiffies, timeout));
/*
......@@ -876,15 +852,14 @@ static inline Scb *alloc_scbs(struct Scsi_Host *host, int needed)
* Otherwise, we timed out and didn't get enough.
*/
if (freescbs < needed) {
printk (KERN_ERR "wd7000: can't get enough free SCBs.\n");
printk(KERN_ERR "wd7000: can't get enough free SCBs.\n");
return (NULL);
}
}
/* Take the lock, then check we didnt get beaten, if so try again */
spin_lock_irqsave(&scbpool_lock, flags);
if(freescbs < needed)
{
if (freescbs < needed) {
spin_unlock_irqrestore(&scbpool_lock, flags);
goto retry;
}
......@@ -904,13 +879,13 @@ static inline Scb *alloc_scbs(struct Scsi_Host *host, int needed)
}
static inline void free_scb (Scb *scb)
static inline void free_scb(Scb * scb)
{
register unsigned long flags;
spin_lock_irqsave(&scbpool_lock, flags);
memset (scb, 0, sizeof (Scb));
memset(scb, 0, sizeof(Scb));
scb->next = scbfree;
scbfree = scb;
freescbs++;
......@@ -919,7 +894,7 @@ static inline void free_scb (Scb *scb)
}
static inline void init_scbs (void)
static inline void init_scbs(void)
{
int i;
......@@ -928,7 +903,7 @@ static inline void init_scbs (void)
/* This is only ever called before the SCB pool is active */
scbfree = &(scbs[0]);
memset (scbs, 0, sizeof (scbs));
memset(scbs, 0, sizeof(scbs));
for (i = 0; i < MAX_SCBS - 1; i++) {
scbs[i].next = &(scbs[i + 1]);
scbs[i].SCpnt = NULL;
......@@ -938,7 +913,7 @@ static inline void init_scbs (void)
}
static int mail_out (Adapter *host, Scb *scbptr)
static int mail_out(Adapter * host, Scb * scbptr)
/*
* Note: this can also be used for ICBs; just cast to the parm type.
*/
......@@ -958,12 +933,11 @@ static int mail_out (Adapter *host, Scb *scbptr)
if (ogmbs[ogmb].status == 0) {
dprintk(" using OGMB 0x%x", ogmb);
ogmbs[ogmb].status = 1;
any2scsi ((unchar *) ogmbs[ogmb].scbptr, (int) scbptr);
any2scsi((unchar *) ogmbs[ogmb].scbptr, (int) scbptr);
*next_ogmb = (ogmb + 1) % OGMB_CNT;
break;
}
else
} else
ogmb = (ogmb + 1) % OGMB_CNT;
}
spin_unlock_irqrestore(host->sh->host_lock, flags);
......@@ -983,10 +957,10 @@ static int mail_out (Adapter *host, Scb *scbptr)
return (0);
}
wd7000_enable_intr (host);
wd7000_enable_intr(host);
start_ogmb = START_OGMB | ogmb;
command_out (host, &start_ogmb, 1);
command_out(host, &start_ogmb, 1);
dprintk(", awaiting interrupt.\n");
......@@ -994,7 +968,7 @@ static int mail_out (Adapter *host, Scb *scbptr)
}
static int make_code (unsigned hosterr, unsigned scsierr)
static int make_code(unsigned hosterr, unsigned scsierr)
{
#ifdef WD7000_DEBUG
int in_error = hosterr;
......@@ -1035,41 +1009,40 @@ static int make_code (unsigned hosterr, unsigned scsierr)
}
#ifdef WD7000_DEBUG
if (scsierr || hosterr)
dprintk("\nSCSI command error: SCSI 0x%02x host 0x%04x return %d\n",
scsierr, in_error, hosterr);
dprintk("\nSCSI command error: SCSI 0x%02x host 0x%04x return %d\n", scsierr, in_error, hosterr);
#endif
return (scsierr | (hosterr << 16));
}
static void wd7000_scsi_done (Scsi_Cmnd *SCpnt)
static void wd7000_scsi_done(Scsi_Cmnd * SCpnt)
{
dprintk("wd7000_scsi_done: 0x%06lx\n", (long)SCpnt);
dprintk("wd7000_scsi_done: 0x%06lx\n", (long) SCpnt);
SCpnt->SCp.phase = 0;
}
#define wd7000_intr_ack(host) outb (0, host->iobase + ASC_INTR_ACK)
static void wd7000_intr_handle (int irq, void *dev_id, struct pt_regs *regs)
static void wd7000_intr_handle(int irq, void *dev_id, struct pt_regs *regs)
{
register int flag, icmb, errstatus, icmb_status;
register int host_error, scsi_error;
register Scb *scb; /* for SCSI commands */
register IcbAny *icb; /* for host commands */
register Scsi_Cmnd *SCpnt;
Adapter *host = (Adapter *)dev_id;
Adapter *host = (Adapter *) dev_id;
Mailbox *icmbs = host->mb.icmb;
host->int_counter++;
dprintk("wd7000_intr_handle: irq = %d, host = 0x%06lx\n", irq, (long) host);
flag = inb (host->iobase + ASC_INTR_STAT);
flag = inb(host->iobase + ASC_INTR_STAT);
dprintk("wd7000_intr_handle: intr stat = 0x%02x\n", flag);
if (!(inb (host->iobase + ASC_STAT) & INT_IM)) {
if (!(inb(host->iobase + ASC_STAT) & INT_IM)) {
/* NB: these are _very_ possible if IRQ 15 is being used, since
* it's the "garbage collector" on the 2nd 8259 PIC. Specifically,
* any interrupt signal into the 8259 which can't be identified
......@@ -1079,7 +1052,7 @@ static void wd7000_intr_handle (int irq, void *dev_id, struct pt_regs *regs)
* problems would be indistinguishable from valid interrupts...
*/
dprintk("wd7000_intr_handle: phantom interrupt...\n");
wd7000_intr_ack (host);
wd7000_intr_ack(host);
return;
}
......@@ -1092,36 +1065,33 @@ static void wd7000_intr_handle (int irq, void *dev_id, struct pt_regs *regs)
* used in mail_out(), wake_up() should correspondingly be called
* here. For now, we don't need to do anything special.
*/
wd7000_intr_ack (host);
wd7000_intr_ack(host);
return;
}
else {
} else {
/* The interrupt is for an incoming mailbox */
icmb = flag & MB_MASK;
icmb_status = icmbs[icmb].status;
if (icmb_status & 0x80) { /* unsolicited - result in ICMB */
dprintk("wd7000_intr_handle: unsolicited interrupt 0x%02x\n",
icmb_status);
wd7000_intr_ack (host);
dprintk("wd7000_intr_handle: unsolicited interrupt 0x%02x\n", icmb_status);
wd7000_intr_ack(host);
return;
}
/* Aaaargh! (Zaga) */
scb = isa_bus_to_virt(scsi2int ((unchar *) icmbs[icmb].scbptr));
scb = isa_bus_to_virt(scsi2int((unchar *) icmbs[icmb].scbptr));
icmbs[icmb].status = 0;
if (!(scb->op & ICB_OP_MASK)) { /* an SCB is done */
SCpnt = scb->SCpnt;
if (--(SCpnt->SCp.phase) <= 0) { /* all scbs are done */
host_error = scb->vue | (icmb_status << 8);
scsi_error = scb->status;
errstatus = make_code (host_error, scsi_error);
errstatus = make_code(host_error, scsi_error);
SCpnt->result = errstatus;
free_scb (scb);
free_scb(scb);
SCpnt->scsi_done (SCpnt);
SCpnt->scsi_done(SCpnt);
}
}
else { /* an ICB is done */
} else { /* an ICB is done */
icb = (IcbAny *) scb;
icb->status = icmb_status;
icb->phase = 0;
......@@ -1129,12 +1099,12 @@ static void wd7000_intr_handle (int irq, void *dev_id, struct pt_regs *regs)
} /* incoming mailbox */
}
wd7000_intr_ack (host);
wd7000_intr_ack(host);
dprintk("wd7000_intr_handle: return from interrupt handler\n");
}
static void do_wd7000_intr_handle (int irq, void *dev_id, struct pt_regs *regs)
static void do_wd7000_intr_handle(int irq, void *dev_id, struct pt_regs *regs)
{
unsigned long flags;
struct Scsi_Host *host = dev_id;
......@@ -1145,7 +1115,7 @@ static void do_wd7000_intr_handle (int irq, void *dev_id, struct pt_regs *regs)
}
static int wd7000_queuecommand (Scsi_Cmnd *SCpnt, void (*done) (Scsi_Cmnd *))
static int wd7000_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
{
register Scb *scb;
register Sgb *sgb;
......@@ -1160,7 +1130,7 @@ static int wd7000_queuecommand (Scsi_Cmnd *SCpnt, void (*done) (Scsi_Cmnd *))
SCpnt->SCp.phase = 1;
scb = alloc_scbs(SCpnt->host, 1);
scb->idlun = idlun;
memcpy (scb->cdb, cdb, cdblen);
memcpy(scb->cdb, cdb, cdblen);
scb->direc = 0x40; /* Disable direction check */
scb->SCpnt = SCpnt; /* so we can find stuff later */
......@@ -1172,42 +1142,39 @@ static int wd7000_queuecommand (Scsi_Cmnd *SCpnt, void (*done) (Scsi_Cmnd *))
unsigned i;
if (SCpnt->host->sg_tablesize == SG_NONE) {
panic ("wd7000_queuecommand: scatter/gather not supported.\n");
panic("wd7000_queuecommand: scatter/gather not supported.\n");
}
dprintk ("Using scatter/gather with %d elements.\n", SCpnt->use_sg);
dprintk("Using scatter/gather with %d elements.\n", SCpnt->use_sg);
sgb = scb->sgb;
scb->op = 1;
any2scsi (scb->dataptr, (int) sgb);
any2scsi (scb->maxlen, SCpnt->use_sg * sizeof (Sgb));
any2scsi(scb->dataptr, (int) sgb);
any2scsi(scb->maxlen, SCpnt->use_sg * sizeof(Sgb));
for (i = 0; i < SCpnt->use_sg; i++) {
any2scsi (sgb[i].ptr,
isa_page_to_bus(sg[i].page) + sg[i].offset);
any2scsi (sgb[i].len, sg[i].length);
}
any2scsi(sgb[i].ptr, isa_page_to_bus(sg[i].page) + sg[i].offset);
any2scsi(sgb[i].len, sg[i].length);
}
else {
} else {
scb->op = 0;
any2scsi (scb->dataptr, isa_virt_to_bus(SCpnt->request_buffer));
any2scsi (scb->maxlen, SCpnt->request_bufflen);
any2scsi(scb->dataptr, isa_virt_to_bus(SCpnt->request_buffer));
any2scsi(scb->maxlen, SCpnt->request_bufflen);
}
/* FIXME: drop lock and yield here ? */
while (!mail_out (host, scb))
while (!mail_out(host, scb))
cpu_relax(); /* keep trying */
return 0;
}
static int wd7000_command (Scsi_Cmnd *SCpnt)
static int wd7000_command(Scsi_Cmnd * SCpnt)
{
wd7000_queuecommand (SCpnt, wd7000_scsi_done);
wd7000_queuecommand(SCpnt, wd7000_scsi_done);
while (SCpnt->SCp.phase > 0)
{
while (SCpnt->SCp.phase > 0) {
cpu_relax();
barrier(); /* phase counts scbs down to 0 */
}
......@@ -1216,36 +1183,34 @@ static int wd7000_command (Scsi_Cmnd *SCpnt)
}
static int wd7000_diagnostics (Adapter *host, int code)
static int wd7000_diagnostics(Adapter * host, int code)
{
static IcbDiag icb = {ICB_OP_DIAGNOSTICS};
static IcbDiag icb = { ICB_OP_DIAGNOSTICS };
static unchar buf[256];
unsigned long timeout;
icb.type = code;
any2scsi (icb.len, sizeof (buf));
any2scsi (icb.ptr, (int) &buf);
any2scsi(icb.len, sizeof(buf));
any2scsi(icb.ptr, (int) &buf);
icb.phase = 1;
/*
* This routine is only called at init, so there should be OGMBs
* available. I'm assuming so here. If this is going to
* fail, I can just let the timeout catch the failure.
*/
mail_out (host, (struct scb *) &icb);
mail_out(host, (struct scb *) &icb);
timeout = jiffies + WAITnexttimeout; /* wait up to 2 seconds */
while (icb.phase && time_before(jiffies, timeout))
{
while (icb.phase && time_before(jiffies, timeout)) {
cpu_relax(); /* wait for completion */
barrier();
}
if (icb.phase) {
printk ("wd7000_diagnostics: timed out.\n");
printk("wd7000_diagnostics: timed out.\n");
return (0);
}
if (make_code (icb.vue | (icb.status << 8), 0)) {
printk ("wd7000_diagnostics: failed (0x%02x,0x%02x)\n",
icb.vue, icb.status);
if (make_code(icb.vue | (icb.status << 8), 0)) {
printk("wd7000_diagnostics: failed (0x%02x,0x%02x)\n", icb.vue, icb.status);
return (0);
}
......@@ -1253,16 +1218,15 @@ static int wd7000_diagnostics (Adapter *host, int code)
}
static int wd7000_adapter_reset(Adapter *host)
static int wd7000_adapter_reset(Adapter * host)
{
InitCmd init_cmd =
{
InitCmd init_cmd = {
INITIALIZATION,
7,
host->bus_on,
host->bus_off,
0,
{ 0, 0, 0 },
{0, 0, 0},
OGMB_CNT,
ICMB_CNT
};
......@@ -1271,74 +1235,81 @@ static int wd7000_adapter_reset(Adapter *host)
* Reset the adapter - only. The SCSI bus was initialized at power-up,
* and we need to do this just so we control the mailboxes, etc.
*/
outb (ASC_RES, host->iobase + ASC_CONTROL);
outb(ASC_RES, host->iobase + ASC_CONTROL);
udelay(40); /* reset pulse: this is 40us, only need 25us */
outb (0, host->iobase + ASC_CONTROL);
outb(0, host->iobase + ASC_CONTROL);
host->control = 0; /* this must always shadow ASC_CONTROL */
if (WAIT (host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) {
printk ("wd7000_init: WAIT timed out.\n");
if (WAIT(host->iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) {
printk("wd7000_init: WAIT timed out.\n");
return -1; /* -1 = not ok */
}
if ((diag = inb (host->iobase + ASC_INTR_STAT)) != 1) {
printk ("wd7000_init: ");
if ((diag = inb(host->iobase + ASC_INTR_STAT)) != 1) {
printk("wd7000_init: ");
switch (diag) {
case 2: printk ("RAM failure.\n");
case 2:
printk("RAM failure.\n");
break;
case 3: printk ("FIFO R/W failed\n");
case 3:
printk("FIFO R/W failed\n");
break;
case 4: printk ("SBIC register R/W failed\n");
case 4:
printk("SBIC register R/W failed\n");
break;
case 5: printk ("Initialization D-FF failed.\n");
case 5:
printk("Initialization D-FF failed.\n");
break;
case 6: printk ("Host IRQ D-FF failed.\n");
case 6:
printk("Host IRQ D-FF failed.\n");
break;
case 7: printk ("ROM checksum error.\n");
case 7:
printk("ROM checksum error.\n");
break;
default: printk ("diagnostic code 0x%02Xh received.\n", diag);
default:
printk("diagnostic code 0x%02Xh received.\n", diag);
}
return -1;
}
/* Clear mailboxes */
memset (&(host->mb), 0, sizeof (host->mb));
memset(&(host->mb), 0, sizeof(host->mb));
/* Execute init command */
any2scsi ((unchar *) & (init_cmd.mailboxes), (int) &(host->mb));
if (!command_out (host, (unchar *) &init_cmd, sizeof (init_cmd))) {
printk (KERN_ERR "wd7000_adapter_reset: adapter initialization failed.\n");
any2scsi((unchar *) & (init_cmd.mailboxes), (int) &(host->mb));
if (!command_out(host, (unchar *) & init_cmd, sizeof(init_cmd))) {
printk(KERN_ERR "wd7000_adapter_reset: adapter initialization failed.\n");
return -1;
}
if (WAIT (host->iobase + ASC_STAT, ASC_STATMASK, ASC_INIT, 0)) {
printk ("wd7000_adapter_reset: WAIT timed out.\n");
if (WAIT(host->iobase + ASC_STAT, ASC_STATMASK, ASC_INIT, 0)) {
printk("wd7000_adapter_reset: WAIT timed out.\n");
return -1;
}
return 0;
}
static int wd7000_init (Adapter *host)
static int wd7000_init(Adapter * host)
{
if(wd7000_adapter_reset(host) == -1)
if (wd7000_adapter_reset(host) == -1)
return 0;
if (request_irq (host->irq, do_wd7000_intr_handle, SA_INTERRUPT, "wd7000", host)) {
printk ("wd7000_init: can't get IRQ %d.\n", host->irq);
if (request_irq(host->irq, do_wd7000_intr_handle, SA_INTERRUPT, "wd7000", host)) {
printk("wd7000_init: can't get IRQ %d.\n", host->irq);
return (0);
}
if (request_dma (host->dma, "wd7000")) {
printk ("wd7000_init: can't get DMA channel %d.\n", host->dma);
free_irq (host->irq, host);
if (request_dma(host->dma, "wd7000")) {
printk("wd7000_init: can't get DMA channel %d.\n", host->dma);
free_irq(host->irq, host);
return (0);
}
wd7000_enable_dma (host);
wd7000_enable_intr (host);
wd7000_enable_dma(host);
wd7000_enable_intr(host);
if (!wd7000_diagnostics (host, ICB_DIAG_FULL)) {
free_dma (host->dma);
free_irq (host->irq, NULL);
if (!wd7000_diagnostics(host, ICB_DIAG_FULL)) {
free_dma(host->dma);
free_irq(host->irq, NULL);
return (0);
}
......@@ -1346,10 +1317,9 @@ static int wd7000_init (Adapter *host)
}
static void wd7000_revision (Adapter *host)
static void wd7000_revision(Adapter * host)
{
static IcbRevLvl icb =
{ICB_OP_GET_REVISION};
static IcbRevLvl icb = { ICB_OP_GET_REVISION };
icb.phase = 1;
/*
......@@ -1358,9 +1328,8 @@ static void wd7000_revision (Adapter *host)
* the only damage will be that the revision will show up as 0.0,
* which in turn means that scatter/gather will be disabled.
*/
mail_out (host, (struct scb *) &icb);
while (icb.phase)
{
mail_out(host, (struct scb *) &icb);
while (icb.phase) {
cpu_relax(); /* wait for completion */
barrier();
}
......@@ -1372,7 +1341,7 @@ static void wd7000_revision (Adapter *host)
#undef SPRINTF
#define SPRINTF(args...) { if (pos < (buffer + length)) pos += sprintf (pos, ## args); }
static int wd7000_set_info (char *buffer, int length, struct Scsi_Host *host)
static int wd7000_set_info(char *buffer, int length, struct Scsi_Host *host)
{
dprintk("Buffer = <%.*s>, length = %d\n", length, buffer, length);
......@@ -1384,7 +1353,7 @@ static int wd7000_set_info (char *buffer, int length, struct Scsi_Host *host)
}
static int wd7000_proc_info (char *buffer, char **start, off_t offset, int length, int hostno, int inout)
static int wd7000_proc_info(char *buffer, char **start, off_t offset, int length, int hostno, int inout)
{
struct Scsi_Host *host = NULL;
Scsi_Device *scd;
......@@ -1411,55 +1380,55 @@ static int wd7000_proc_info (char *buffer, char **start, off_t offset, int lengt
/*
* Host not found!
*/
if (! host)
if (!host)
return (-ESRCH);
/*
* Has data been written to the file ?
*/
if (inout)
return (wd7000_set_info (buffer, length, host));
return (wd7000_set_info(buffer, length, host));
adapter = (Adapter *) host->hostdata;
spin_lock_irqsave(host->host_lock, flags);
SPRINTF ("Host scsi%d: Western Digital WD-7000 (rev %d.%d)\n", hostno, adapter->rev1, adapter->rev2);
SPRINTF (" IO base: 0x%x\n", adapter->iobase);
SPRINTF (" IRQ: %d\n", adapter->irq);
SPRINTF (" DMA channel: %d\n", adapter->dma);
SPRINTF (" Interrupts: %d\n", adapter->int_counter);
SPRINTF (" BUS_ON time: %d nanoseconds\n", adapter->bus_on * 125);
SPRINTF (" BUS_OFF time: %d nanoseconds\n", adapter->bus_off * 125);
SPRINTF("Host scsi%d: Western Digital WD-7000 (rev %d.%d)\n", hostno, adapter->rev1, adapter->rev2);
SPRINTF(" IO base: 0x%x\n", adapter->iobase);
SPRINTF(" IRQ: %d\n", adapter->irq);
SPRINTF(" DMA channel: %d\n", adapter->dma);
SPRINTF(" Interrupts: %d\n", adapter->int_counter);
SPRINTF(" BUS_ON time: %d nanoseconds\n", adapter->bus_on * 125);
SPRINTF(" BUS_OFF time: %d nanoseconds\n", adapter->bus_off * 125);
#ifdef WD7000_DEBUG
ogmbs = adapter->mb.ogmb;
icmbs = adapter->mb.icmb;
SPRINTF ("\nControl port value: 0x%x\n", adapter->control);
SPRINTF ("Incoming mailbox:\n");
SPRINTF (" size: %d\n", ICMB_CNT);
SPRINTF (" queued messages: ");
SPRINTF("\nControl port value: 0x%x\n", adapter->control);
SPRINTF("Incoming mailbox:\n");
SPRINTF(" size: %d\n", ICMB_CNT);
SPRINTF(" queued messages: ");
for (i = count = 0; i < ICMB_CNT; i++)
if (icmbs[i].status) {
count++;
SPRINTF ("0x%x ", i);
SPRINTF("0x%x ", i);
}
SPRINTF (count ? "\n" : "none\n");
SPRINTF(count ? "\n" : "none\n");
SPRINTF ("Outgoing mailbox:\n");
SPRINTF (" size: %d\n", OGMB_CNT);
SPRINTF (" next message: 0x%x\n", adapter->next_ogmb);
SPRINTF (" queued messages: ");
SPRINTF("Outgoing mailbox:\n");
SPRINTF(" size: %d\n", OGMB_CNT);
SPRINTF(" next message: 0x%x\n", adapter->next_ogmb);
SPRINTF(" queued messages: ");
for (i = count = 0; i < OGMB_CNT; i++)
if (ogmbs[i].status) {
count++;
SPRINTF ("0x%x ", i);
SPRINTF("0x%x ", i);
}
SPRINTF (count ? "\n" : "none\n");
SPRINTF(count ? "\n" : "none\n");
#endif
/*
......@@ -1467,25 +1436,23 @@ static int wd7000_proc_info (char *buffer, char **start, off_t offset, int lengt
*/
scd = host->host_queue;
SPRINTF ("\nAttached devices: %s\n", scd ? "" : "none");
SPRINTF("\nAttached devices: %s\n", scd ? "" : "none");
for ( ; scd; scd = scd->next)
for (; scd; scd = scd->next)
if (scd->host->host_no == hostno) {
SPRINTF (" [Channel: %02d, Id: %02d, Lun: %02d] ",
scd->channel, scd->id, scd->lun);
SPRINTF ("%s ", (scd->type < MAX_SCSI_DEVICE_CODE) ?
scsi_device_types[(short) scd->type] : "Unknown device");
SPRINTF(" [Channel: %02d, Id: %02d, Lun: %02d] ", scd->channel, scd->id, scd->lun);
SPRINTF("%s ", (scd->type < MAX_SCSI_DEVICE_CODE) ? scsi_device_types[(short) scd->type] : "Unknown device");
for (i = 0; (i < 8) && (scd->vendor[i] >= 0x20); i++)
SPRINTF ("%c", scd->vendor[i]);
SPRINTF (" ");
SPRINTF("%c", scd->vendor[i]);
SPRINTF(" ");
for (i = 0; (i < 16) && (scd->model[i] >= 0x20); i++)
SPRINTF ("%c", scd->model[i]);
SPRINTF ("\n");
SPRINTF("%c", scd->model[i]);
SPRINTF("\n");
}
SPRINTF ("\n");
SPRINTF("\n");
spin_unlock_irqrestore(host->host_lock, flags);
......@@ -1514,7 +1481,7 @@ static int wd7000_proc_info (char *buffer, char **start, off_t offset, int lengt
*
*/
static int wd7000_detect (Scsi_Host_Template *tpnt)
static int wd7000_detect(Scsi_Host_Template * tpnt)
{
short present = 0, biosaddr_ptr, sig_ptr, i, pass;
short biosptr[NUM_CONFIGS];
......@@ -1530,8 +1497,8 @@ static int wd7000_detect (Scsi_Host_Template *tpnt)
wd7000_setup(wd7000);
#endif
for (i = 0; i < UNITS; wd7000_host[i++] = NULL) ;
for (i = 0; i < NUM_CONFIGS; biosptr[i++] = -1) ;
for (i = 0; i < UNITS; wd7000_host[i++] = NULL);
for (i = 0; i < NUM_CONFIGS; biosptr[i++] = -1);
tpnt->proc_name = "wd7000";
tpnt->proc_info = &wd7000_proc_info;
......@@ -1539,7 +1506,7 @@ static int wd7000_detect (Scsi_Host_Template *tpnt)
/*
* Set up SCB free list, which is shared by all adapters
*/
init_scbs ();
init_scbs();
for (pass = 0; pass < NUM_CONFIGS; pass++) {
/*
......@@ -1552,18 +1519,16 @@ static int wd7000_detect (Scsi_Host_Template *tpnt)
break;
if (i == pass) {
void *biosaddr = ioremap (wd7000_biosaddr[biosaddr_ptr] +
signatures[sig_ptr].ofs,
void *biosaddr = ioremap(wd7000_biosaddr[biosaddr_ptr] + signatures[sig_ptr].ofs,
signatures[sig_ptr].len);
short bios_match=0;
short bios_match = 0;
if(biosaddr)
bios_match = memcmp ((char *) biosaddr, signatures[sig_ptr].sig,
signatures[sig_ptr].len);
if (biosaddr)
bios_match = memcmp((char *) biosaddr, signatures[sig_ptr].sig, signatures[sig_ptr].len);
iounmap (biosaddr);
iounmap(biosaddr);
if (! bios_match)
if (!bios_match)
goto bios_matched;
}
}
......@@ -1578,8 +1543,7 @@ static int wd7000_detect (Scsi_Host_Template *tpnt)
if (biosaddr_ptr == NUM_ADDRS)
dprintk("WD-7000 SST BIOS not detected...\n");
else
dprintk("WD-7000 SST BIOS detected at 0x%lx: checking...\n",
wd7000_biosaddr[biosaddr_ptr]);
dprintk("WD-7000 SST BIOS detected at 0x%lx: checking...\n", wd7000_biosaddr[biosaddr_ptr]);
#endif
if (configs[pass].irq < 0)
......@@ -1592,24 +1556,24 @@ static int wd7000_detect (Scsi_Host_Template *tpnt)
dprintk("wd7000_detect: check IO 0x%x region...\n", iobase);
if (request_region (iobase, 4, "wd7000")) {
if (request_region(iobase, 4, "wd7000")) {
dprintk("wd7000_detect: ASC reset (IO 0x%x) ...", iobase);
/*
* ASC reset...
*/
outb (ASC_RES, iobase + ASC_CONTROL);
outb(ASC_RES, iobase + ASC_CONTROL);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout(HZ/100);
outb (0, iobase + ASC_CONTROL);
schedule_timeout(HZ / 100);
outb(0, iobase + ASC_CONTROL);
if (WAIT (iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) {
if (WAIT(iobase + ASC_STAT, ASC_STATMASK, CMD_RDY, 0)) {
dprintk("failed!\n");
goto err_release;
} else
dprintk("ok!\n");
if (inb (iobase + ASC_INTR_STAT) == 1) {
if (inb(iobase + ASC_INTR_STAT) == 1) {
/*
* We register here, to get a pointer to the extra space,
* which we'll use as the Adapter structure (host) for
......@@ -1617,15 +1581,14 @@ static int wd7000_detect (Scsi_Host_Template *tpnt)
* Scsi_Host structure (sh), and is located by the empty
* array hostdata.
*/
sh = scsi_register (tpnt, sizeof (Adapter));
if(sh==NULL)
sh = scsi_register(tpnt, sizeof(Adapter));
if (sh == NULL)
goto err_release;
host = (Adapter *) sh->hostdata;
dprintk("wd7000_detect: adapter allocated at 0x%x\n",
(int)host);
memset (host, 0, sizeof (Adapter));
dprintk("wd7000_detect: adapter allocated at 0x%x\n", (int) host);
memset(host, 0, sizeof(Adapter));
host->irq = configs[pass].irq;
host->dma = configs[pass].dma;
......@@ -1636,17 +1599,15 @@ static int wd7000_detect (Scsi_Host_Template *tpnt)
host->sh = wd7000_host[unit] = sh;
unit++;
dprintk("wd7000_detect: Trying init WD-7000 card at IO "
"0x%x, IRQ %d, DMA %d...\n",
host->iobase, host->irq, host->dma);
dprintk("wd7000_detect: Trying init WD-7000 card at IO " "0x%x, IRQ %d, DMA %d...\n", host->iobase, host->irq, host->dma);
if (!wd7000_init (host)) /* Initialization failed */
if (!wd7000_init(host)) /* Initialization failed */
goto err_unregister;
/*
* OK from here - we'll use this adapter/configuration.
*/
wd7000_revision (host); /* important for scatter/gather */
wd7000_revision(host); /* important for scatter/gather */
/*
* For boards before rev 6.0, scatter/gather isn't supported.
......@@ -1659,28 +1620,24 @@ static int wd7000_detect (Scsi_Host_Template *tpnt)
if (biosaddr_ptr != NUM_ADDRS)
biosptr[pass] = biosaddr_ptr;
printk (KERN_INFO "Western Digital WD-7000 (rev %d.%d) ",
host->rev1, host->rev2);
printk ("using IO 0x%x, IRQ %d, DMA %d.\n",
host->iobase, host->irq, host->dma);
printk (" BUS_ON time: %dns, BUS_OFF time: %dns\n",
host->bus_on * 125, host->bus_off * 125);
printk(KERN_INFO "Western Digital WD-7000 (rev %d.%d) ", host->rev1, host->rev2);
printk("using IO 0x%x, IRQ %d, DMA %d.\n", host->iobase, host->irq, host->dma);
printk(" BUS_ON time: %dns, BUS_OFF time: %dns\n", host->bus_on * 125, host->bus_off * 125);
}
} else
dprintk("wd7000_detect: IO 0x%x region already allocated!\n",
iobase);
dprintk("wd7000_detect: IO 0x%x region already allocated!\n", iobase);
continue;
err_unregister:
scsi_unregister (sh);
scsi_unregister(sh);
err_release:
release_region(iobase, 4);
}
if (!present)
printk ("Failed initialization of WD-7000 SCSI card!\n");
printk("Failed initialization of WD-7000 SCSI card!\n");
return (present);
}
......@@ -1689,13 +1646,13 @@ static int wd7000_detect (Scsi_Host_Template *tpnt)
/*
* I have absolutely NO idea how to do an abort with the WD7000...
*/
static int wd7000_abort (Scsi_Cmnd *SCpnt)
static int wd7000_abort(Scsi_Cmnd * SCpnt)
{
Adapter *host = (Adapter *) SCpnt->host->hostdata;
if (inb (host->iobase + ASC_STAT) & INT_IM) {
printk ("wd7000_abort: lost interrupt\n");
wd7000_intr_handle (host->irq, NULL, NULL);
if (inb(host->iobase + ASC_STAT) & INT_IM) {
printk("wd7000_abort: lost interrupt\n");
wd7000_intr_handle(host->irq, NULL, NULL);
return FAILED;
}
return FAILED;
......@@ -1706,12 +1663,12 @@ static int wd7000_abort (Scsi_Cmnd *SCpnt)
* I also have no idea how to do a reset...
*/
static int wd7000_bus_reset (Scsi_Cmnd *SCpnt)
static int wd7000_bus_reset(Scsi_Cmnd * SCpnt)
{
return FAILED;
}
static int wd7000_device_reset (Scsi_Cmnd *SCpnt)
static int wd7000_device_reset(Scsi_Cmnd * SCpnt)
{
return FAILED;
}
......@@ -1720,13 +1677,13 @@ static int wd7000_device_reset (Scsi_Cmnd *SCpnt)
* Last resort. Reinitialize the board.
*/
static int wd7000_host_reset (Scsi_Cmnd *SCpnt)
static int wd7000_host_reset(Scsi_Cmnd * SCpnt)
{
Adapter *host = (Adapter *) SCpnt->host->hostdata;
if(wd7000_adapter_reset(host)<0)
if (wd7000_adapter_reset(host) < 0)
return FAILED;
wd7000_enable_intr (host);
wd7000_enable_intr(host);
return SUCCESS;
}
......@@ -1735,10 +1692,9 @@ static int wd7000_host_reset (Scsi_Cmnd *SCpnt)
* This was borrowed directly from aha1542.c. (Zaga)
*/
static int wd7000_biosparam (Disk *disk, struct block_device *bdev, int *ip)
static int wd7000_biosparam(Disk * disk, struct block_device *bdev, int *ip)
{
dprintk("wd7000_biosparam: dev=%s, size=%d, ", bdevname(bdev),
disk->capacity);
dprintk("wd7000_biosparam: dev=%s, size=%d, ", bdevname(bdev), disk->capacity);
/*
* try default translation
......@@ -1756,24 +1712,19 @@ static int wd7000_biosparam (Disk *disk, struct block_device *bdev, int *ip)
/*
* try to figure out the geometry from the partition table
*/
if ((scsicam_bios_param (disk, bdev, info) < 0) ||
!(((info[0] == 64) && (info[1] == 32)) ||
((info[0] == 255) && (info[1] == 63)))) {
printk ("wd7000_biosparam: unable to verify geometry for disk with >1GB.\n"
" using extended translation.\n");
if ((scsicam_bios_param(disk, bdev, info) < 0) || !(((info[0] == 64) && (info[1] == 32)) || ((info[0] == 255) && (info[1] == 63)))) {
printk("wd7000_biosparam: unable to verify geometry for disk with >1GB.\n" " using extended translation.\n");
ip[0] = 255;
ip[1] = 63;
ip[2] = (unsigned long)disk->capacity / (255 * 63);
}
else {
ip[2] = (unsigned long) disk->capacity / (255 * 63);
} else {
ip[0] = info[0];
ip[1] = info[1];
ip[2] = info[2];
if (info[0] == 255)
printk(KERN_INFO "%s: current partition table is "
"using extended translation.\n", __FUNCTION__);
printk(KERN_INFO "%s: current partition table is " "using extended translation.\n", __FUNCTION__);
}
}
......
drivers/scsi/wd7000.h
View file @ 994b3fb0
......@@ -13,16 +13,16 @@
#include <linux/types.h>
static int wd7000_set_info (char *buffer, int length, struct Scsi_Host *host);
static int wd7000_proc_info (char *buffer, char **start, off_t offset, int length, int hostno, int inout);
static int wd7000_detect (Scsi_Host_Template *);
static int wd7000_command (Scsi_Cmnd *);
static int wd7000_queuecommand (Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
static int wd7000_abort (Scsi_Cmnd *);
static int wd7000_bus_reset (Scsi_Cmnd *);
static int wd7000_host_reset (Scsi_Cmnd *);
static int wd7000_device_reset (Scsi_Cmnd *);
static int wd7000_biosparam (Disk *, struct block_device *, int *);
static int wd7000_set_info(char *buffer, int length, struct Scsi_Host *host);
static int wd7000_proc_info(char *buffer, char **start, off_t offset, int length, int hostno, int inout);
static int wd7000_detect(Scsi_Host_Template *);
static int wd7000_command(Scsi_Cmnd *);
static int wd7000_queuecommand(Scsi_Cmnd *, void (*done) (Scsi_Cmnd *));
static int wd7000_abort(Scsi_Cmnd *);
static int wd7000_bus_reset(Scsi_Cmnd *);
static int wd7000_host_reset(Scsi_Cmnd *);
static int wd7000_device_reset(Scsi_Cmnd *);
static int wd7000_biosparam(Disk *, struct block_device *, int *);
#ifndef NULL
#define NULL 0L
......
include/asm-alpha/pal.h
View file @ 994b3fb0
......@@ -45,7 +45,7 @@
#define PAL_wrperfmon 57
#define PAL_rdusp 58
#define PAL_whami 60
#define PAL_rtsys 61
#define PAL_retsys 61
#define PAL_rti 63
#endif /* __ALPHA_PAL_H */
include/asm-alpha/unistd.h
View file @ 994b3fb0
......@@ -343,7 +343,7 @@
#define __NR_alloc_hugepages 403
#define __NR_free_hugepages 404
#define __NR_exit_group 405
#define NR_SYSCALLS 406
#if defined(__GNUC__)
......@@ -598,7 +598,7 @@ static inline pid_t waitpid(int pid, int * wait_stat, int flags)
return sys_wait4(pid, wait_stat, flags, NULL);
}
#endif
#endif /* __KERNEL_SYSCALLS__ */
/*
* "Conditional" syscalls
......
include/asm-generic/siginfo.h
View file @ 994b3fb0
......@@ -91,7 +91,7 @@ typedef struct siginfo {
#define __SI_FAULT (3 << 16)
#define __SI_CHLD (4 << 16)
#define __SI_RT (5 << 16)
#define __SI_CODE(T,N) ((T) << 16 | ((N) & 0xffff))
#define __SI_CODE(T,N) ((T) | ((N) & 0xffff))
#else
#define __SI_KILL 0
#define __SI_TIMER 0
......
include/linux/ide.h
View file @ 994b3fb0
......@@ -794,6 +794,7 @@ typedef struct ide_drive_s {
int lun; /* logical unit */
int crc_count; /* crc counter to reduce drive speed */
struct list_head list;
struct device gendev;
struct gendisk *disk;
} ide_drive_t;
......@@ -1199,6 +1200,7 @@ typedef struct ide_driver_s {
int (*attach)(ide_drive_t *);
void (*ata_prebuilder)(ide_drive_t *);
void (*atapi_prebuilder)(ide_drive_t *);
struct device_driver gen_driver;
struct list_head drives;
struct list_head drivers;
} ide_driver_t;
......
kernel/timer.c
View file @ 994b3fb0
......@@ -799,9 +799,17 @@ asmlinkage unsigned long sys_alarm(unsigned int seconds)
* should be moved into arch/i386 instead?
*/
/**
* sys_getpid - return the thread group id of the current process
*
* Note, despite the name, this returns the tgid not the pid. The tgid and
* the pid are identical unless CLONE_THREAD was specified on clone() in
* which case the tgid is the same in all threads of the same group.
*
* This is SMP safe as current->tgid does not change.
*/
asmlinkage long sys_getpid(void)
{
/* This is SMP safe - current->pid doesn't change */
return current->tgid;
}
......
lib/brlock.c
View file @ 994b3fb0
......@@ -24,8 +24,9 @@ void __br_write_lock (enum brlock_indices idx)
{
int i;
preempt_disable();
for (i = 0; i < NR_CPUS; i++)
write_lock(&__brlock_array[i][idx]);
_raw_write_lock(&__brlock_array[i][idx]);
}
void __br_write_unlock (enum brlock_indices idx)
......@@ -33,7 +34,8 @@ void __br_write_unlock (enum brlock_indices idx)
int i;
for (i = 0; i < NR_CPUS; i++)
write_unlock(&__brlock_array[i][idx]);
_raw_write_unlock(&__brlock_array[i][idx]);
preempt_enable();
}
#else /* ! __BRLOCK_USE_ATOMICS */
......@@ -48,11 +50,12 @@ void __br_write_lock (enum brlock_indices idx)
{
int i;
preempt_disable();
again:
spin_lock(&__br_write_locks[idx].lock);
_raw_spin_lock(&__br_write_locks[idx].lock);
for (i = 0; i < NR_CPUS; i++)
if (__brlock_array[i][idx] != 0) {
spin_unlock(&__br_write_locks[idx].lock);
_raw_spin_unlock(&__br_write_locks[idx].lock);
barrier();
cpu_relax();
goto again;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7