Skip to content

L
linux
Commit 43130446 authored by Alexander Viro's avatar Alexander Viro Committed by Linus Torvalds
Browse files
Options

[PATCH] Lindent pf.c 

pf.c fed through lindent
parent e714bc9e
Show whitespace changes
Inline Side-by-side
Showing with 561 additions and 512 deletions
drivers/block/paride/pf.c
View file @ 43130446
......@@ -131,12 +131,12 @@ static int cluster = 64;
static int nice = 0;
static int disable = 0;
static int drive0[7] = {0,0,0,-1,-1,-1,-1};
static int drive1[7] = {0,0,0,-1,-1,-1,-1};
static int drive2[7] = {0,0,0,-1,-1,-1,-1};
static int drive3[7] = {0,0,0,-1,-1,-1,-1};
static int drive0[7] = { 0, 0, 0, -1, -1, -1, -1 };
static int drive1[7] = { 0, 0, 0, -1, -1, -1, -1 };
static int drive2[7] = { 0, 0, 0, -1, -1, -1, -1 };
static int drive3[7] = { 0, 0, 0, -1, -1, -1, -1 };
static int (*drives[4])[7] = {&drive0,&drive1,&drive2,&drive3};
static int (*drives[4])[7] = {&drive0, &drive1, &drive2, &drive3};
static int pf_drive_count;
#define D_PRT 0
......@@ -151,7 +151,6 @@ static int pf_drive_count;
/* end of parameters */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
......@@ -168,30 +167,32 @@ static spinlock_t pf_spin_lock;
#include "setup.h"
static STT pf_stt[7] = {{"drive0",7,drive0},
{"drive1",7,drive1},
{"drive2",7,drive2},
{"drive3",7,drive3},
{"disable",1,&disable},
{"cluster",1,&cluster},
{"nice",1,&nice}};
void pf_setup( char *str, int *ints)
static STT pf_stt[7] = {
{"drive0", 7, drive0},
{"drive1", 7, drive1},
{"drive2", 7, drive2},
{"drive3", 7, drive3},
{"disable", 1, &disable},
{"cluster", 1, &cluster},
{"nice", 1, &nice}
};
{ generic_setup(pf_stt,7,str);
void pf_setup(char *str, int *ints)
{
generic_setup(pf_stt, 7, str);
}
#endif
MODULE_PARM(verbose,"i");
MODULE_PARM(major,"i");
MODULE_PARM(name,"s");
MODULE_PARM(cluster,"i");
MODULE_PARM(nice,"i");
MODULE_PARM(drive0,"1-7i");
MODULE_PARM(drive1,"1-7i");
MODULE_PARM(drive2,"1-7i");
MODULE_PARM(drive3,"1-7i");
MODULE_PARM(verbose, "i");
MODULE_PARM(major, "i");
MODULE_PARM(name, "s");
MODULE_PARM(cluster, "i");
MODULE_PARM(nice, "i");
MODULE_PARM(drive0, "1-7i");
MODULE_PARM(drive1, "1-7i");
MODULE_PARM(drive2, "1-7i");
MODULE_PARM(drive3, "1-7i");
#include "paride.h"
......@@ -238,24 +239,24 @@ MODULE_PARM(drive3,"1-7i");
#define ATAPI_WRITE_10 0x2a
#ifdef MODULE
void cleanup_module( void );
void cleanup_module(void);
#endif
static int pf_open(struct inode *inode, struct file *file);
static void do_pf_request(request_queue_t * q);
static int pf_ioctl(struct inode *inode,struct file *file,
static int pf_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg);
static int pf_release (struct inode *inode, struct file *file);
static int pf_release(struct inode *inode, struct file *file);
static int pf_detect(void);
static void do_pf_read(void);
static void do_pf_read_start(void);
static void do_pf_write(void);
static void do_pf_write_start(void);
static void do_pf_read_drq( void );
static void do_pf_write_done( void );
static void do_pf_read_drq(void);
static void do_pf_write_done(void);
static int pf_identify (int unit);
static int pf_identify(int unit);
static void pf_lock(int unit, int func);
static void pf_eject(int unit);
static int pf_check_media(kdev_t dev);
......@@ -277,7 +278,7 @@ struct pf_unit {
int capacity; /* Size of this volume in sectors */
int present; /* device present ? */
char name[PF_NAMELEN]; /* pf0, pf1, ... */
};
};
struct pf_unit pf[PF_UNITS];
......@@ -300,25 +301,25 @@ static int pf_run; /* sectors in current cluster */
static int pf_cmd; /* current command READ/WRITE */
static int pf_unit; /* unit of current request */
static int pf_mask; /* stopper for pseudo-int */
static char * pf_buf; /* buffer for request in progress */
static char *pf_buf; /* buffer for request in progress */
/* kernel glue structures */
static struct block_device_operations pf_fops = {
owner: THIS_MODULE,
open: pf_open,
release: pf_release,
ioctl: pf_ioctl,
check_media_change: pf_check_media,
owner:THIS_MODULE,
open:pf_open,
release:pf_release,
ioctl:pf_ioctl,
check_media_change:pf_check_media,
};
void pf_init_units( void )
{ int unit, j;
void pf_init_units(void)
{
int unit, j;
pf_drive_count = 0;
for (unit=0;unit<PF_UNITS;unit++) {
PF.pi = & PF.pia;
for (unit = 0; unit < PF_UNITS; unit++) {
PF.pi = &PF.pia;
PF.access = 0;
PF.media_status = PF_NM;
PF.capacity = 0;
......@@ -326,43 +327,49 @@ void pf_init_units( void )
PF.drive = DU[D_SLV];
PF.lun = DU[D_LUN];
j = 0;
while ((j < PF_NAMELEN-2) && (PF.name[j]=name[j])) j++;
while ((j < PF_NAMELEN - 2) && (PF.name[j] = name[j]))
j++;
PF.name[j++] = '0' + unit;
PF.name[j] = 0;
if (DU[D_PRT]) pf_drive_count++;
if (DU[D_PRT])
pf_drive_count++;
}
}
static int pf_open (struct inode *inode, struct file *file)
{ int unit = DEVICE_NR(inode->i_rdev);
static int pf_open(struct inode *inode, struct file *file)
{
int unit = DEVICE_NR(inode->i_rdev);
if ((unit >= PF_UNITS) || (!PF.present)) return -ENODEV;
if ((unit >= PF_UNITS) || (!PF.present))
return -ENODEV;
pf_identify(unit);
if (PF.media_status == PF_NM)
return -ENODEV;
if ((PF.media_status == PF_RO) && (file ->f_mode & 2))
if ((PF.media_status == PF_RO) && (file->f_mode & 2))
return -EROFS;
PF.access++;
if (PF.removable) pf_lock(unit,1);
if (PF.removable)
pf_lock(unit, 1);
return 0;
}
static int pf_ioctl(struct inode *inode,struct file *file,
unsigned int cmd, unsigned long arg)
{ int err, unit;
static int pf_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
int err, unit;
struct hd_geometry *geo = (struct hd_geometry *) arg;
if ((!inode) || kdev_none(inode->i_rdev)) return -EINVAL;
if ((!inode) || kdev_none(inode->i_rdev))
return -EINVAL;
unit = DEVICE_NR(inode->i_rdev);
if (unit >= PF_UNITS) return -EINVAL;
if (!PF.present) return -ENODEV;
if (unit >= PF_UNITS)
return -EINVAL;
if (!PF.present)
return -ENODEV;
switch (cmd) {
case CDROMEJECT:
......@@ -371,35 +378,36 @@ static int pf_ioctl(struct inode *inode,struct file *file,
return 0;
}
case HDIO_GETGEO:
if (!geo) return -EINVAL;
err = verify_area(VERIFY_WRITE,geo,sizeof(*geo));
if (err) return err;
if (!geo)
return -EINVAL;
err = verify_area(VERIFY_WRITE, geo, sizeof (*geo));
if (err)
return err;
if (PF.capacity < PF_FD_MAX) {
put_user(PF.capacity/(PF_FD_HDS*PF_FD_SPT),
put_user(PF.capacity / (PF_FD_HDS * PF_FD_SPT),
(short *) &geo->cylinders);
put_user(PF_FD_HDS, (char *) &geo->heads);
put_user(PF_FD_SPT, (char *) &geo->sectors);
} else {
put_user(PF.capacity/(PF_HD_HDS*PF_HD_SPT),
put_user(PF.capacity / (PF_HD_HDS * PF_HD_SPT),
(short *) &geo->cylinders);
put_user(PF_HD_HDS, (char *) &geo->heads);
put_user(PF_HD_SPT, (char *) &geo->sectors);
}
put_user(0,(long *)&geo->start);
put_user(0, (long *) &geo->start);
return 0;
case BLKGETSIZE:
return put_user(PF.capacity,(long *) arg);
return put_user(PF.capacity, (long *) arg);
case BLKGETSIZE64:
return put_user((u64)PF.capacity << 9,(u64 *)arg);
return put_user((u64) PF.capacity << 9, (u64 *) arg);
default:
return -EINVAL;
}
}
static int pf_release (struct inode *inode, struct file *file)
{ kdev_t devp;
static int pf_release(struct inode *inode, struct file *file)
{
kdev_t devp;
int unit;
devp = inode->i_rdev;
......@@ -411,15 +419,15 @@ static int pf_release (struct inode *inode, struct file *file)
PF.access--;
if (!PF.access && PF.removable)
pf_lock(unit,0);
pf_lock(unit, 0);
return 0;
}
static int pf_check_media( kdev_t dev)
{ return 1;
static int pf_check_media(kdev_t dev)
{
return 1;
}
static inline int status_reg(int unit)
......@@ -440,100 +448,108 @@ static inline void write_reg(int unit, int reg, int val)
#define LUN (0x20*PF.lun)
#define DRIVE (0xa0+0x10*PF.drive)
static int pf_wait( int unit, int go, int stop, char * fun, char * msg )
{ int j, r, e, s, p;
static int pf_wait(int unit, int go, int stop, char *fun, char *msg)
{
int j, r, e, s, p;
j = 0;
while ((((r=status_reg(unit))&go)||(stop&&(!(r&stop))))&&(j++<PF_SPIN))
while ((((r = status_reg(unit)) & go) || (stop && (!(r & stop))))
&& (j++ < PF_SPIN))
udelay(PF_SPIN_DEL);
if ((r&(STAT_ERR&stop))||(j>=PF_SPIN)) {
if ((r & (STAT_ERR & stop)) || (j >= PF_SPIN)) {
s = read_reg(unit, 7);
e = read_reg(unit, 1);
p = read_reg(unit, 2);
if (j >= PF_SPIN) e |= 0x100;
if (fun) printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
if (j >= PF_SPIN)
e |= 0x100;
if (fun)
printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
" loop=%d phase=%d\n",
PF.name,fun,msg,r,s,e,j,p);
return (e<<8)+s;
PF.name, fun, msg, r, s, e, j, p);
return (e << 8) + s;
}
return 0;
}
static int pf_command( int unit, char * cmd, int dlen, char * fun )
{ pi_connect(PI);
static int pf_command(int unit, char *cmd, int dlen, char *fun)
{
pi_connect(PI);
write_reg(unit, 6,DRIVE);
write_reg(unit, 6, DRIVE);
if (pf_wait(unit,STAT_BUSY|STAT_DRQ,0,fun,"before command")) {
if (pf_wait(unit, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
pi_disconnect(PI);
return -1;
}
write_reg(unit, 4,dlen % 256);
write_reg(unit, 5,dlen / 256);
write_reg(unit, 7,0xa0); /* ATAPI packet command */
write_reg(unit, 4, dlen % 256);
write_reg(unit, 5, dlen / 256);
write_reg(unit, 7, 0xa0); /* ATAPI packet command */
if (pf_wait(unit,STAT_BUSY,STAT_DRQ,fun,"command DRQ")) {
if (pf_wait(unit, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
pi_disconnect(PI);
return -1;
}
if (read_reg(unit, 2) != 1) {
printk("%s: %s: command phase error\n",PF.name,fun);
printk("%s: %s: command phase error\n", PF.name, fun);
pi_disconnect(PI);
return -1;
}
pi_write_block(PI,cmd,12);
pi_write_block(PI, cmd, 12);
return 0;
}
static int pf_completion( int unit, char * buf, char * fun )
{ int r, s, n;
static int pf_completion(int unit, char *buf, char *fun)
{
int r, s, n;
r = pf_wait(unit,STAT_BUSY,STAT_DRQ|STAT_READY|STAT_ERR,
fun,"completion");
r = pf_wait(unit, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
fun, "completion");
if ((read_reg(unit, 2)&2) && (read_reg(unit, 7)&STAT_DRQ)) {
n = (((read_reg(unit, 4)+256*read_reg(unit, 5))+3)&0xfffc);
pi_read_block(PI,buf,n);
if ((read_reg(unit, 2) & 2) && (read_reg(unit, 7) & STAT_DRQ)) {
n = (((read_reg(unit, 4) + 256 * read_reg(unit, 5)) +
3) & 0xfffc);
pi_read_block(PI, buf, n);
}
s = pf_wait(unit,STAT_BUSY,STAT_READY|STAT_ERR,fun,"data done");
s = pf_wait(unit, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
pi_disconnect(PI);
return (r?r:s);
return (r ? r : s);
}
static void pf_req_sense( int unit, int quiet )
{ char rs_cmd[12] = { ATAPI_REQ_SENSE,LUN,0,0,16,0,0,0,0,0,0,0 };
static void pf_req_sense(int unit, int quiet)
{
char rs_cmd[12] =
{ ATAPI_REQ_SENSE, LUN, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
char buf[16];
int r;
r = pf_command(unit,rs_cmd,16,"Request sense");
r = pf_command(unit, rs_cmd, 16, "Request sense");
mdelay(1);
if (!r) pf_completion(unit,buf,"Request sense");
if (!r)
pf_completion(unit, buf, "Request sense");
if ((!r)&&(!quiet))
if ((!r) && (!quiet))
printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
PF.name,buf[2]&0xf,buf[12],buf[13]);
PF.name, buf[2] & 0xf, buf[12], buf[13]);
}
static int pf_atapi( int unit, char * cmd, int dlen, char * buf, char * fun )
{ int r;
static int pf_atapi(int unit, char *cmd, int dlen, char *buf, char *fun)
{
int r;
r = pf_command(unit,cmd,dlen,fun);
r = pf_command(unit, cmd, dlen, fun);
mdelay(1);
if (!r) r = pf_completion(unit,buf,fun);
if (r) pf_req_sense(unit,!fun);
if (!r)
r = pf_completion(unit, buf, fun);
if (r)
pf_req_sense(unit, !fun);
return r;
}
......@@ -541,136 +557,145 @@ static int pf_atapi( int unit, char * cmd, int dlen, char * buf, char * fun )
#define DBMSG(msg) ((verbose>1)?(msg):NULL)
static void pf_lock(int unit, int func)
{
char lo_cmd[12] = { ATAPI_LOCK, LUN, 0, 0, func, 0, 0, 0, 0, 0, 0, 0 };
{ char lo_cmd[12] = { ATAPI_LOCK,LUN,0,0,func,0,0,0,0,0,0,0 };
pf_atapi(unit,lo_cmd,0,pf_scratch,func?"unlock":"lock");
pf_atapi(unit, lo_cmd, 0, pf_scratch, func ? "unlock" : "lock");
}
static void pf_eject(int unit)
{
char ej_cmd[12] = { ATAPI_DOOR, LUN, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 };
static void pf_eject( int unit )
{ char ej_cmd[12] = { ATAPI_DOOR,LUN,0,0,2,0,0,0,0,0,0,0 };
pf_lock(unit,0);
pf_atapi(unit,ej_cmd,0,pf_scratch,"eject");
pf_lock(unit, 0);
pf_atapi(unit, ej_cmd, 0, pf_scratch, "eject");
}
#define PF_RESET_TMO 30 /* in tenths of a second */
static void pf_sleep( int cs )
{ current->state = TASK_INTERRUPTIBLE;
static void pf_sleep(int cs)
{
current->state = TASK_INTERRUPTIBLE;
schedule_timeout(cs);
}
static int pf_reset( int unit )
/* the ATAPI standard actually specifies the contents of all 7 registers
after a reset, but the specification is ambiguous concerning the last
two bytes, and different drives interpret the standard differently.
*/
*/
{ int i, k, flg;
int expect[5] = {1,1,1,0x14,0xeb};
static int pf_reset(int unit)
{
int i, k, flg;
int expect[5] = { 1, 1, 1, 0x14, 0xeb };
pi_connect(PI);
write_reg(unit, 6,DRIVE);
write_reg(unit, 7,8);
write_reg(unit, 6, DRIVE);
write_reg(unit, 7, 8);
pf_sleep(20*HZ/1000);
pf_sleep(20 * HZ / 1000);
k = 0;
while ((k++ < PF_RESET_TMO) && (status_reg(unit)&STAT_BUSY))
pf_sleep(HZ/10);
while ((k++ < PF_RESET_TMO) && (status_reg(unit) & STAT_BUSY))
pf_sleep(HZ / 10);
flg = 1;
for(i=0;i<5;i++) flg &= (read_reg(unit, i+1) == expect[i]);
for (i = 0; i < 5; i++)
flg &= (read_reg(unit, i + 1) == expect[i]);
if (verbose) {
printk("%s: Reset (%d) signature = ",PF.name,k);
for (i=0;i<5;i++) printk("%3x",read_reg(unit, i+1));
if (!flg) printk(" (incorrect)");
printk("%s: Reset (%d) signature = ", PF.name, k);
for (i = 0; i < 5; i++)
printk("%3x", read_reg(unit, i + 1));
if (!flg)
printk(" (incorrect)");
printk("\n");
}
pi_disconnect(PI);
return flg-1;
return flg - 1;
}
static void pf_mode_sense( int unit )
{ char ms_cmd[12] = { ATAPI_MODE_SENSE,LUN,0,0,0,0,0,0,8,0,0,0};
static void pf_mode_sense(int unit)
{
char ms_cmd[12] =
{ ATAPI_MODE_SENSE, LUN, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0 };
char buf[8];
pf_atapi(unit,ms_cmd,8,buf,DBMSG("mode sense"));
pf_atapi(unit, ms_cmd, 8, buf, DBMSG("mode sense"));
PF.media_status = PF_RW;
if (buf[3] & 0x80) PF.media_status = PF_RO;
if (buf[3] & 0x80)
PF.media_status = PF_RO;
}
static void xs( char *buf, char *targ, int offs, int len )
{ int j,k,l;
static void xs(char *buf, char *targ, int offs, int len)
{
int j, k, l;
j=0; l=0;
for (k=0;k<len;k++)
if((buf[k+offs]!=0x20)||(buf[k+offs]!=l))
l=targ[j++]=buf[k+offs];
if (l==0x20) j--;
targ[j]=0;
j = 0;
l = 0;
for (k = 0; k < len; k++)
if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
l = targ[j++] = buf[k + offs];
if (l == 0x20)
j--;
targ[j] = 0;
}
static int xl( char *buf, int offs )
{ int v,k;
static int xl(char *buf, int offs)
{
int v, k;
v=0;
for(k=0;k<4;k++) v=v*256+(buf[k+offs]&0xff);
v = 0;
for (k = 0; k < 4; k++)
v = v * 256 + (buf[k + offs] & 0xff);
return v;
}
static void pf_get_capacity( int unit )
{ char rc_cmd[12] = { ATAPI_CAPACITY,LUN,0,0,0,0,0,0,0,0,0,0};
static void pf_get_capacity(int unit)
{
char rc_cmd[12] = { ATAPI_CAPACITY, LUN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
char buf[8];
int bs;
if (pf_atapi(unit,rc_cmd,8,buf,DBMSG("get capacity"))) {
if (pf_atapi(unit, rc_cmd, 8, buf, DBMSG("get capacity"))) {
PF.media_status = PF_NM;
return;
}
PF.capacity = xl(buf,0) + 1;
bs = xl(buf,4);
PF.capacity = xl(buf, 0) + 1;
bs = xl(buf, 4);
if (bs != 512) {
PF.capacity = 0;
if (verbose) printk("%s: Drive %d, LUN %d,"
if (verbose)
printk("%s: Drive %d, LUN %d,"
" unsupported block size %d\n",
PF.name,PF.drive,PF.lun,bs);
PF.name, PF.drive, PF.lun, bs);
}
}
static int pf_identify( int unit )
{ int dt, s;
char *ms[2] = {"master","slave"};
static int pf_identify(int unit)
{
int dt, s;
char *ms[2] = { "master", "slave" };
char mf[10], id[18];
char id_cmd[12] = { ATAPI_IDENTIFY,LUN,0,0,36,0,0,0,0,0,0,0};
char id_cmd[12] =
{ ATAPI_IDENTIFY, LUN, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
char buf[36];
s = pf_atapi(unit,id_cmd,36,buf,"identify");
if (s) return -1;
s = pf_atapi(unit, id_cmd, 36, buf, "identify");
if (s)
return -1;
dt = buf[0] & 0x1f;
if ((dt != 0) && (dt != 7)) {
if (verbose)
printk("%s: Drive %d, LUN %d, unsupported type %d\n",
PF.name,PF.drive,PF.lun,dt);
PF.name, PF.drive, PF.lun, dt);
return -1;
}
xs(buf,mf,8,8);
xs(buf,id,16,16);
xs(buf, mf, 8, 8);
xs(buf, id, 16, 16);
PF.removable = (buf[1] & 0x80);
......@@ -681,108 +706,123 @@ static int pf_identify( int unit )
pf_get_capacity(unit);
printk("%s: %s %s, %s LUN %d, type %d",
PF.name,mf,id,ms[PF.drive],PF.lun,dt);
if (PF.removable) printk(", removable");
PF.name, mf, id, ms[PF.drive], PF.lun, dt);
if (PF.removable)
printk(", removable");
if (PF.media_status == PF_NM)
printk(", no media\n");
else { if (PF.media_status == PF_RO) printk(", RO");
printk(", %d blocks\n",PF.capacity);
else {
if (PF.media_status == PF_RO)
printk(", RO");
printk(", %d blocks\n", PF.capacity);
}
return 0;
}
static int pf_probe( int unit )
/* returns 0, with id set if drive is detected
-1, if drive detection failed
*/
{ if (PF.drive == -1) {
for (PF.drive=0;PF.drive<=1;PF.drive++)
static int pf_probe(int unit)
{
if (PF.drive == -1) {
for (PF.drive = 0; PF.drive <= 1; PF.drive++)
if (!pf_reset(unit)) {
if (PF.lun != -1) return pf_identify(unit);
else for (PF.lun=0;PF.lun<8;PF.lun++)
if (!pf_identify(unit)) return 0;
if (PF.lun != -1)
return pf_identify(unit);
else
for (PF.lun = 0; PF.lun < 8; PF.lun++)
if (!pf_identify(unit))
return 0;
}
} else {
if (pf_reset(unit)) return -1;
if (PF.lun != -1) return pf_identify(unit);
for (PF.lun=0;PF.lun<8;PF.lun++)
if (!pf_identify(unit)) return 0;
if (pf_reset(unit))
return -1;
if (PF.lun != -1)
return pf_identify(unit);
for (PF.lun = 0; PF.lun < 8; PF.lun++)
if (!pf_identify(unit))
return 0;
}
return -1;
}
static int pf_detect( void )
{ int k, unit;
static int pf_detect(void)
{
int k, unit;
printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
name,name,PF_VERSION,major,cluster,nice);
name, name, PF_VERSION, major, cluster, nice);
k = 0;
if (pf_drive_count == 0) {
unit = 0;
if (pi_init(PI,1,-1,-1,-1,-1,-1,pf_scratch,
PI_PF,verbose,PF.name)) {
if (pi_init(PI, 1, -1, -1, -1, -1, -1, pf_scratch,
PI_PF, verbose, PF.name)) {
if (!pf_probe(unit)) {
PF.present = 1;
k++;
} else pi_release(PI);
} else
pi_release(PI);
}
} else for (unit=0;unit<PF_UNITS;unit++) if (DU[D_PRT])
if (pi_init(PI,0,DU[D_PRT],DU[D_MOD],DU[D_UNI],
DU[D_PRO],DU[D_DLY],pf_scratch,PI_PF,verbose,
PF.name)) {
} else
for (unit = 0; unit < PF_UNITS; unit++)
if (DU[D_PRT])
if (pi_init
(PI, 0, DU[D_PRT], DU[D_MOD], DU[D_UNI],
DU[D_PRO], DU[D_DLY], pf_scratch, PI_PF,
verbose, PF.name)) {
if (!pf_probe(unit)) {
PF.present = 1;
k++;
} else pi_release(PI);
} else
pi_release(PI);
}
if (k) return 0;
if (k)
return 0;
printk("%s: No ATAPI disk detected\n",name);
printk("%s: No ATAPI disk detected\n", name);
return -1;
}
/* The i/o request engine */
static int pf_start( int unit, int cmd, int b, int c )
{ int i;
char io_cmd[12] = {cmd,LUN,0,0,0,0,0,0,0,0,0,0};
static int pf_start(int unit, int cmd, int b, int c)
{
int i;
char io_cmd[12] = { cmd, LUN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
for(i=0;i<4;i++) {
io_cmd[5-i] = b & 0xff;
for (i = 0; i < 4; i++) {
io_cmd[5 - i] = b & 0xff;
b = b >> 8;
}
io_cmd[8] = c & 0xff;
io_cmd[7] = (c >> 8) & 0xff;
i = pf_command(unit,io_cmd,c*512,"start i/o");
i = pf_command(unit, io_cmd, c * 512, "start i/o");
mdelay(1);
return i;
}
static int pf_ready( void )
{ int unit = pf_unit;
static int pf_ready(void)
{
int unit = pf_unit;
return (((status_reg(unit)&(STAT_BUSY|pf_mask)) == pf_mask));
return (((status_reg(unit) & (STAT_BUSY | pf_mask)) == pf_mask));
}
static void do_pf_request (request_queue_t * q)
static void do_pf_request(request_queue_t * q)
{
int unit;
if (pf_busy) return;
repeat:
if (pf_busy)
return;
repeat:
if (blk_queue_empty(QUEUE))
return;
......@@ -791,7 +831,7 @@ static void do_pf_request (request_queue_t * q)
pf_run = CURRENT->nr_sectors;
pf_count = CURRENT->current_nr_sectors;
if ((pf_unit >= PF_UNITS) || (pf_block+pf_count > PF.capacity)) {
if ((pf_unit >= PF_UNITS) || (pf_block + pf_count > PF.capacity)) {
end_request(CURRENT, 0);
goto repeat;
}
......@@ -801,21 +841,25 @@ static void do_pf_request (request_queue_t * q)
pf_retries = 0;
pf_busy = 1;
if (pf_cmd == READ) pi_do_claimed(PI,do_pf_read);
else if (pf_cmd == WRITE) pi_do_claimed(PI,do_pf_write);
else { pf_busy = 0;
if (pf_cmd == READ)
pi_do_claimed(PI, do_pf_read);
else if (pf_cmd == WRITE)
pi_do_claimed(PI, do_pf_write);
else {
pf_busy = 0;
end_request(CURRENT, 0);
goto repeat;
}
}
static void pf_next_buf( int unit )
{ long saved_flags;
static void pf_next_buf(int unit)
{
long saved_flags;
spin_lock_irqsave(&pf_spin_lock,saved_flags);
spin_lock_irqsave(&pf_spin_lock, saved_flags);
end_request(CURRENT, 1);
if (!pf_run) { spin_unlock_irqrestore(&pf_spin_lock,saved_flags);
if (!pf_run) {
spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
return;
}
......@@ -830,163 +874,168 @@ static void pf_next_buf( int unit )
pf_count = CURRENT->current_nr_sectors;
pf_buf = CURRENT->buffer;
spin_unlock_irqrestore(&pf_spin_lock,saved_flags);
spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
}
static void do_pf_read( void )
/* detach from the calling context - in case the spinlock is held */
{ ps_set_intr(do_pf_read_start,0,0,nice);
static void do_pf_read(void)
{
ps_set_intr(do_pf_read_start, 0, 0, nice);
}
static void do_pf_read_start( void )
{ int unit = pf_unit;
static void do_pf_read_start(void)
{
int unit = pf_unit;
long saved_flags;
pf_busy = 1;
if (pf_start(unit,ATAPI_READ_10,pf_block,pf_run)) {
if (pf_start(unit, ATAPI_READ_10, pf_block, pf_run)) {
pi_disconnect(PI);
if (pf_retries < PF_MAX_RETRIES) {
pf_retries++;
pi_do_claimed(PI,do_pf_read_start);
pi_do_claimed(PI, do_pf_read_start);
return;
}
spin_lock_irqsave(&pf_spin_lock,saved_flags);
spin_lock_irqsave(&pf_spin_lock, saved_flags);
end_request(CURRENT, 0);
pf_busy = 0;
do_pf_request(NULL);
spin_unlock_irqrestore(&pf_spin_lock,saved_flags);
spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
return;
}
pf_mask = STAT_DRQ;
ps_set_intr(do_pf_read_drq,pf_ready,PF_TMO,nice);
ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
}
static void do_pf_read_drq( void )
{ int unit = pf_unit;
static void do_pf_read_drq(void)
{
int unit = pf_unit;
long saved_flags;
while (1) {
if (pf_wait(unit,STAT_BUSY,STAT_DRQ|STAT_ERR,
"read block","completion") & STAT_ERR) {
if (pf_wait(unit, STAT_BUSY, STAT_DRQ | STAT_ERR,
"read block", "completion") & STAT_ERR) {
pi_disconnect(PI);
if (pf_retries < PF_MAX_RETRIES) {
pf_req_sense(unit,0);
pf_req_sense(unit, 0);
pf_retries++;
pi_do_claimed(PI,do_pf_read_start);
pi_do_claimed(PI, do_pf_read_start);
return;
}
spin_lock_irqsave(&pf_spin_lock,saved_flags);
spin_lock_irqsave(&pf_spin_lock, saved_flags);
end_request(CURRENT, 0);
pf_busy = 0;
do_pf_request(NULL);
spin_unlock_irqrestore(&pf_spin_lock,saved_flags);
spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
return;
}
pi_read_block(PI,pf_buf,512);
pf_count--; pf_run--;
pi_read_block(PI, pf_buf, 512);
pf_count--;
pf_run--;
pf_buf += 512;
pf_block++;
if (!pf_run) break;
if (!pf_count) pf_next_buf(unit);
if (!pf_run)
break;
if (!pf_count)
pf_next_buf(unit);
}
pi_disconnect(PI);
spin_lock_irqsave(&pf_spin_lock,saved_flags);
spin_lock_irqsave(&pf_spin_lock, saved_flags);
end_request(CURRENT, 1);
pf_busy = 0;
do_pf_request(NULL);
spin_unlock_irqrestore(&pf_spin_lock,saved_flags);
spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
}
static void do_pf_write( void )
{ ps_set_intr(do_pf_write_start,0,0,nice);
static void do_pf_write(void)
{
ps_set_intr(do_pf_write_start, 0, 0, nice);
}
static void do_pf_write_start( void )
{ int unit = pf_unit;
static void do_pf_write_start(void)
{
int unit = pf_unit;
long saved_flags;
pf_busy = 1;
if (pf_start(unit,ATAPI_WRITE_10,pf_block,pf_run)) {
if (pf_start(unit, ATAPI_WRITE_10, pf_block, pf_run)) {
pi_disconnect(PI);
if (pf_retries < PF_MAX_RETRIES) {
pf_retries++;
pi_do_claimed(PI,do_pf_write_start);
pi_do_claimed(PI, do_pf_write_start);
return;
}
spin_lock_irqsave(&pf_spin_lock,saved_flags);
spin_lock_irqsave(&pf_spin_lock, saved_flags);
end_request(CURRENT, 0);
pf_busy = 0;
do_pf_request(NULL);
spin_unlock_irqrestore(&pf_spin_lock,saved_flags);
spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
return;
}
while (1) {
if (pf_wait(unit,STAT_BUSY,STAT_DRQ|STAT_ERR,
"write block","data wait") & STAT_ERR) {
if (pf_wait(unit, STAT_BUSY, STAT_DRQ | STAT_ERR,
"write block", "data wait") & STAT_ERR) {
pi_disconnect(PI);
if (pf_retries < PF_MAX_RETRIES) {
pf_retries++;
pi_do_claimed(PI,do_pf_write_start);
pi_do_claimed(PI, do_pf_write_start);
return;
}
spin_lock_irqsave(&pf_spin_lock,saved_flags);
spin_lock_irqsave(&pf_spin_lock, saved_flags);
end_request(CURRENT, 0);
pf_busy = 0;
do_pf_request(NULL);
spin_unlock_irqrestore(&pf_spin_lock,saved_flags);
spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
return;
}
pi_write_block(PI,pf_buf,512);
pf_count--; pf_run--;
pi_write_block(PI, pf_buf, 512);
pf_count--;
pf_run--;
pf_buf += 512;
pf_block++;
if (!pf_run) break;
if (!pf_count) pf_next_buf(unit);
if (!pf_run)
break;
if (!pf_count)
pf_next_buf(unit);
}
pf_mask = 0;
ps_set_intr(do_pf_write_done,pf_ready,PF_TMO,nice);
ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
}
static void do_pf_write_done( void )
{ int unit = pf_unit;
static void do_pf_write_done(void)
{
int unit = pf_unit;
long saved_flags;
if (pf_wait(unit,STAT_BUSY,0,"write block","done") & STAT_ERR) {
if (pf_wait(unit, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
pi_disconnect(PI);
if (pf_retries < PF_MAX_RETRIES) {
pf_retries++;
pi_do_claimed(PI,do_pf_write_start);
pi_do_claimed(PI, do_pf_write_start);
return;
}
spin_lock_irqsave(&pf_spin_lock,saved_flags);
spin_lock_irqsave(&pf_spin_lock, saved_flags);
end_request(CURRENT, 0);
pf_busy = 0;
do_pf_request(NULL);
spin_unlock_irqrestore(&pf_spin_lock,saved_flags);
spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
return;
}
pi_disconnect(PI);
spin_lock_irqsave(&pf_spin_lock,saved_flags);
spin_lock_irqsave(&pf_spin_lock, saved_flags);
end_request(CURRENT, 1);
pf_busy = 0;
do_pf_request(NULL);
spin_unlock_irqrestore(&pf_spin_lock,saved_flags);
spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
}
static int __init pf_init(void) /* preliminary initialisation */
{
static int __init pf_init(void)
{ /* preliminary initialisation */
int i;
request_queue_t * q;
request_queue_t *q;
if (disable)
return -1;
......@@ -997,7 +1046,7 @@ static int __init pf_init(void) /* preliminary initialisation */
return -1;
pf_busy = 0;
if (register_blkdev(MAJOR_NR,name,&pf_fops)) {
if (register_blkdev(MAJOR_NR, name, &pf_fops)) {
printk("pf_init: unable to get major number %d\n", major);
return -1;
}
......@@ -1006,7 +1055,7 @@ static int __init pf_init(void) /* preliminary initialisation */
blk_queue_max_phys_segments(q, cluster);
blk_queue_max_hw_segments(q, cluster);
for (i=0;i<PF_UNITS;i++)
for (i = 0; i < PF_UNITS; i++)
register_disk(NULL, mk_kdev(MAJOR_NR, i), 1, &pf_fops, 0);
return 0;
......@@ -1015,8 +1064,8 @@ static int __init pf_init(void) /* preliminary initialisation */
static void __exit pf_exit(void)
{
int unit;
unregister_blkdev(MAJOR_NR,name);
for (unit=0;unit<PF_UNITS;unit++)
unregister_blkdev(MAJOR_NR, name);
for (unit = 0; unit < PF_UNITS; unit++)
if (PF.present)
pi_release(PI);
}
......
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