sys/src/cmd/scuzz/cdr.c

   1 #include <u.h>
   2 #include <libc.h>
   3
   4 #include "scsireq.h"
   5
   6 long
   7 SRblank(ScsiReq *rp, uchar type, uchar track)
   8 {
   9         uchar cmd[12];
  10
  11         memset(cmd, 0, sizeof(cmd));
  12         cmd[0] = ScmdBlank;
  13         cmd[1] = type;
  14         cmd[2] = track>>24;
  15         cmd[3] = track>>16;
  16         cmd[4] = track>>8;
  17         cmd[5] = track;
  18         rp->cmd.p = cmd;
  19         rp->cmd.count = sizeof(cmd);
  20         rp->data.p = cmd;
  21         rp->data.count = 0;
  22         rp->data.write = 1;
  23         return SRrequest(rp);
  24 }
  25
  26 long
  27 SRsynccache(ScsiReq *rp)
  28 {
  29         uchar cmd[10];
  30
  31         memset(cmd, 0, sizeof(cmd));
  32         cmd[0] = ScmdSynccache;
  33         rp->cmd.p = cmd;
  34         rp->cmd.count = sizeof(cmd);
  35         rp->data.p = cmd;
  36         rp->data.count = 0;
  37         rp->data.write = 1;
  38         return SRrequest(rp);
  39 }
  40
  41 long
  42 SRTOC(ScsiReq *rp, void *data, int nbytes, uchar format, uchar track)
  43 {
  44         uchar cmd[10];
  45
  46         memset(cmd, 0, sizeof(cmd));
  47         cmd[0] = ScmdRTOC;
  48         cmd[2] = format;
  49         cmd[6] = track;
  50         cmd[7] = nbytes>>8;
  51         cmd[8] = nbytes;
  52         rp->cmd.p = cmd;
  53         rp->cmd.count = sizeof(cmd);
  54         rp->data.p = data;
  55         rp->data.count = nbytes;
  56         rp->data.write = 0;
  57         return SRrequest(rp);
  58 }
  59
  60 long
  61 SRrdiscinfo(ScsiReq *rp, void *data, int nbytes)
  62 {
  63         uchar cmd[10];
  64
  65         memset(cmd, 0, sizeof(cmd));
  66         cmd[0] = ScmdRdiscinfo;
  67         cmd[7] = nbytes>>8;
  68         cmd[8] = nbytes;
  69         rp->cmd.p = cmd;
  70         rp->cmd.count = sizeof(cmd);
  71         rp->data.p = data;
  72         rp->data.count = nbytes;
  73         rp->data.write = 0;
  74         return SRrequest(rp);
  75 }
  76
  77 long
  78 SRrtrackinfo(ScsiReq *rp, void *data, int nbytes, int track)
  79 {
  80         uchar cmd[10];
  81
  82         memset(cmd, 0, sizeof(cmd));
  83         cmd[0] = ScmdRtrackinfo;
  84         cmd[1] = 0x01;
  85         cmd[2] = track>>24;
  86         cmd[3] = track>>16;
  87         cmd[4] = track>>8;
  88         cmd[5] = track;
  89         cmd[7] = nbytes>>8;
  90         cmd[8] = nbytes;
  91         rp->cmd.p = cmd;
  92         rp->cmd.count = sizeof(cmd);
  93         rp->data.p = data;
  94         rp->data.count = nbytes;
  95         rp->data.write = 0;
  96         return SRrequest(rp);
  97 }
  98
  99 long
 100 SRfwaddr(ScsiReq *rp, uchar track, uchar mode, uchar npa, uchar *data)
 101 {
 102         uchar cmd[10];
 103
 104         memset(cmd, 0, sizeof(cmd));
 105         cmd[0] = ScmdFwaddr;
 106         cmd[2] = track;
 107         cmd[3] = mode;
 108         cmd[7] = npa;
 109         rp->cmd.p = cmd;
 110         rp->cmd.count = sizeof(cmd);
 111         rp->data.p = data;
 112         rp->data.count = MaxDirData;
 113         rp->data.write = 0;
 114         return SRrequest(rp);
 115 }
 116
 117 long
 118 SRtreserve(ScsiReq *rp, long nbytes)
 119 {
 120         uchar cmd[10];
 121         long n;
 122
 123         if((nbytes % rp->lbsize)){
 124                 rp->status = Status_BADARG;
 125                 return -1;
 126         }
 127         memset(cmd, 0, sizeof(cmd));
 128         cmd[0] = ScmdTreserve;
 129         n = nbytes/rp->lbsize;
 130         cmd[5] = n>>24;
 131         cmd[6] = n>>16;
 132         cmd[7] = n>>8;
 133         cmd[8] = n;
 134         rp->cmd.p = cmd;
 135         rp->cmd.count = sizeof(cmd);
 136         rp->data.p = cmd;
 137         rp->data.count = 0;
 138         rp->data.write = 1;
 139         return SRrequest(rp);
 140 }
 141
 142 long
 143 SRtinfo(ScsiReq *rp, uchar track, uchar *data)
 144 {
 145         uchar cmd[10];
 146
 147         memset(cmd, 0, sizeof(cmd));
 148         cmd[0] = ScmdTinfo;
 149         cmd[5] = track;
 150         cmd[8] = MaxDirData;
 151         rp->cmd.p = cmd;
 152         rp->cmd.count = sizeof(cmd);
 153         rp->data.p = data;
 154         rp->data.count = MaxDirData;
 155         rp->data.write = 0;
 156         return SRrequest(rp);
 157 }
 158
 159 long
 160 SRwtrack(ScsiReq *rp, void *buf, long nbytes, uchar track, uchar mode)
 161 {
 162         uchar cmd[10];
 163         long m, n;
 164
 165         if((nbytes % rp->lbsize) || nbytes > maxiosize){
 166                 rp->status = Status_BADARG;
 167                 return -1;
 168         }
 169         memset(cmd, 0, sizeof(cmd));
 170         cmd[0] = ScmdTwrite;
 171         cmd[5] = track;
 172         cmd[6] = mode;
 173         n = nbytes/rp->lbsize;
 174         cmd[7] = n>>8;
 175         cmd[8] = n;
 176         rp->cmd.p = cmd;
 177         rp->cmd.count = sizeof(cmd);
 178         rp->data.p = buf;
 179         rp->data.count = nbytes;
 180         rp->data.write = 1;
 181         m = SRrequest(rp);
 182         if(m < 0)
 183                 return -1;
 184         rp->offset += n;
 185         return m;
 186 }
 187
 188 long
 189 SRmload(ScsiReq *rp, uchar code)
 190 {
 191         uchar cmd[12];
 192
 193         memset(cmd, 0, sizeof(cmd));
 194         cmd[0] = ScmdMload;
 195         cmd[8] = code;
 196         rp->cmd.p = cmd;
 197         rp->cmd.count = sizeof(cmd);
 198         rp->data.p = cmd;
 199         rp->data.count = 0;
 200         rp->data.write = 1;
 201         return SRrequest(rp);
 202 }
 203
 204 long
 205 SRfixation(ScsiReq *rp, uchar type)
 206 {
 207         uchar cmd[10];
 208
 209         memset(cmd, 0, sizeof(cmd));
 210         cmd[0] = ScmdFixation;
 211         cmd[8] = type;
 212         rp->cmd.p = cmd;
 213         rp->cmd.count = sizeof(cmd);
 214         rp->data.p = cmd;
 215         rp->data.count = 0;
 216         rp->data.write = 1;
 217         return SRrequest(rp);
 218 }