drivers/staging/keucr/msscsi.c

   1 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   2
   3 #include <linux/sched.h>
   4 #include <linux/errno.h>
   5 #include <linux/slab.h>
   6
   7 #include <scsi/scsi.h>
   8 #include <scsi/scsi_eh.h>
   9 #include <scsi/scsi_device.h>
  10
  11 #include "usb.h"
  12 #include "scsiglue.h"
  13 #include "transport.h"
  14
  15 /*
  16  * MS_SCSI_Test_Unit_Ready()
  17  */
  18 int MS_SCSI_Test_Unit_Ready(struct us_data *us, struct scsi_cmnd *srb)
  19 {
  20         /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */
  21         if (us->MS_Status.Insert && us->MS_Status.Ready)
  22                 return USB_STOR_TRANSPORT_GOOD;
  23         else {
  24                 ENE_MSInit(us);
  25                 return USB_STOR_TRANSPORT_GOOD;
  26         }
  27
  28         return USB_STOR_TRANSPORT_GOOD;
  29 }
  30
  31 /*
  32  * MS_SCSI_Inquiry()
  33  */
  34 int MS_SCSI_Inquiry(struct us_data *us, struct scsi_cmnd *srb)
  35 {
  36         /* pr_info("MS_SCSI_Inquiry\n"); */
  37         BYTE data_ptr[36] = {0x00, 0x80, 0x02, 0x00, 0x1F, 0x00,
  38                                 0x00, 0x00, 0x55, 0x53, 0x42, 0x32,
  39                                 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
  40                                 0x72, 0x64, 0x52, 0x65, 0x61, 0x64,
  41                                 0x65, 0x72, 0x20, 0x20, 0x20, 0x20,
  42                                 0x20, 0x20, 0x30, 0x31, 0x30, 0x30};
  43
  44         usb_stor_set_xfer_buf(us, data_ptr, 36, srb, TO_XFER_BUF);
  45         return USB_STOR_TRANSPORT_GOOD;
  46 }
  47
  48 /*
  49  * MS_SCSI_Mode_Sense()
  50  */
  51 int MS_SCSI_Mode_Sense(struct us_data *us, struct scsi_cmnd *srb)
  52 {
  53         BYTE    mediaNoWP[12] = {0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
  54                                         0x71, 0xc0, 0x00, 0x00, 0x02, 0x00};
  55         BYTE    mediaWP[12]   = {0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
  56                                         0x71, 0xc0, 0x00, 0x00, 0x02, 0x00};
  57
  58         if (us->MS_Status.WtP)
  59                 usb_stor_set_xfer_buf(us, mediaWP, 12, srb, TO_XFER_BUF);
  60         else
  61                 usb_stor_set_xfer_buf(us, mediaNoWP, 12, srb, TO_XFER_BUF);
  62
  63
  64         return USB_STOR_TRANSPORT_GOOD;
  65 }
  66
  67 /*
  68  * MS_SCSI_Read_Capacity()
  69  */
  70 int MS_SCSI_Read_Capacity(struct us_data *us, struct scsi_cmnd *srb)
  71 {
  72         unsigned int offset = 0;
  73         struct scatterlist *sg = NULL;
  74         DWORD   bl_num;
  75         WORD    bl_len;
  76         BYTE    buf[8];
  77
  78         pr_info("MS_SCSI_Read_Capacity\n");
  79
  80         bl_len = 0x200;
  81         if (us->MS_Status.IsMSPro)
  82                 bl_num = us->MSP_TotalBlock - 1;
  83         else
  84                 bl_num = us->MS_Lib.NumberOfLogBlock *
  85                                 us->MS_Lib.blockSize * 2 - 1;
  86
  87         us->bl_num = bl_num;
  88         pr_info("bl_len = %x\n", bl_len);
  89         pr_info("bl_num = %x\n", bl_num);
  90
  91         /* srb->request_bufflen = 8; */
  92         buf[0] = (bl_num >> 24) & 0xff;
  93         buf[1] = (bl_num >> 16) & 0xff;
  94         buf[2] = (bl_num >> 8) & 0xff;
  95         buf[3] = (bl_num >> 0) & 0xff;
  96         buf[4] = (bl_len >> 24) & 0xff;
  97         buf[5] = (bl_len >> 16) & 0xff;
  98         buf[6] = (bl_len >> 8) & 0xff;
  99         buf[7] = (bl_len >> 0) & 0xff;
 100
 101         usb_stor_access_xfer_buf(us, buf, 8, srb, &sg, &offset, TO_XFER_BUF);
 102         /* usb_stor_set_xfer_buf(us, buf, srb->request_bufflen,
 103                                                 srb, TO_XFER_BUF); */
 104
 105         return USB_STOR_TRANSPORT_GOOD;
 106 }
 107
 108 /*
 109  * MS_SCSI_Read()
 110  */
 111 int MS_SCSI_Read(struct us_data *us, struct scsi_cmnd *srb)
 112 {
 113         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 114         int result = 0;
 115         PBYTE   Cdb = srb->cmnd;
 116         DWORD bn  =  ((Cdb[2] << 24) & 0xff000000) |
 117                         ((Cdb[3] << 16) & 0x00ff0000) |
 118                         ((Cdb[4] << 8) & 0x0000ff00) |
 119                         ((Cdb[5] << 0) & 0x000000ff);
 120         WORD  blen = ((Cdb[7] << 8) & 0xff00) | ((Cdb[8] << 0) & 0x00ff);
 121         DWORD   blenByte = blen * 0x200;
 122
 123         /* pr_info("SCSIOP_READ --- bn = %X, blen = %X, srb->use_sg = %X\n",
 124                                                 bn, blen, srb->use_sg); */
 125
 126         if (bn > us->bl_num)
 127                 return USB_STOR_TRANSPORT_ERROR;
 128
 129         if (us->MS_Status.IsMSPro) {
 130                 result = ENE_LoadBinCode(us, MSP_RW_PATTERN);
 131                 if (result != USB_STOR_XFER_GOOD) {
 132                         pr_info("Load MSP RW pattern Fail !!\n");
 133                         return USB_STOR_TRANSPORT_ERROR;
 134                 }
 135
 136                 /*  set up the command wrapper */
 137                 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 138                 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 139                 bcb->DataTransferLength = blenByte;
 140                 bcb->Flags  = 0x80;
 141                 bcb->CDB[0] = 0xF1;
 142                 bcb->CDB[1] = 0x02;
 143                 bcb->CDB[5] = (BYTE)(bn);
 144                 bcb->CDB[4] = (BYTE)(bn>>8);
 145                 bcb->CDB[3] = (BYTE)(bn>>16);
 146                 bcb->CDB[2] = (BYTE)(bn>>24);
 147
 148                 result = ENE_SendScsiCmd(us, FDIR_READ, scsi_sglist(srb), 1);
 149         } else {
 150                 void    *buf;
 151                 int     offset = 0;
 152                 WORD    phyblk, logblk;
 153                 BYTE    PageNum;
 154                 WORD    len;
 155                 DWORD   blkno;
 156
 157                 buf = kmalloc(blenByte, GFP_KERNEL);
 158                 if (buf == NULL)
 159                         return USB_STOR_TRANSPORT_ERROR;
 160
 161                 result = ENE_LoadBinCode(us, MS_RW_PATTERN);
 162                 if (result != USB_STOR_XFER_GOOD) {
 163                         pr_info("Load MS RW pattern Fail !!\n");
 164                         result = USB_STOR_TRANSPORT_ERROR;
 165                         goto exit;
 166                 }
 167
 168                 logblk  = (WORD)(bn / us->MS_Lib.PagesPerBlock);
 169                 PageNum = (BYTE)(bn % us->MS_Lib.PagesPerBlock);
 170
 171                 while (1) {
 172                         if (blen > (us->MS_Lib.PagesPerBlock-PageNum))
 173                                 len = us->MS_Lib.PagesPerBlock-PageNum;
 174                         else
 175                                 len = blen;
 176
 177                         phyblk = MS_LibConv2Physical(us, logblk);
 178                         blkno  = phyblk * 0x20 + PageNum;
 179
 180                         /* set up the command wrapper */
 181                         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 182                         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 183                         bcb->DataTransferLength = 0x200 * len;
 184                         bcb->Flags  = 0x80;
 185                         bcb->CDB[0] = 0xF1;
 186                         bcb->CDB[1] = 0x02;
 187                         bcb->CDB[5] = (BYTE)(blkno);
 188                         bcb->CDB[4] = (BYTE)(blkno>>8);
 189                         bcb->CDB[3] = (BYTE)(blkno>>16);
 190                         bcb->CDB[2] = (BYTE)(blkno>>24);
 191
 192                         result = ENE_SendScsiCmd(us, FDIR_READ, buf+offset, 0);
 193                         if (result != USB_STOR_XFER_GOOD) {
 194                                 pr_info("MS_SCSI_Read --- result = %x\n",
 195                                                                 result);
 196                                 result =  USB_STOR_TRANSPORT_ERROR;
 197                                 goto exit;
 198                         }
 199
 200                         blen -= len;
 201                         if (blen <= 0)
 202                                 break;
 203                         logblk++;
 204                         PageNum = 0;
 205                         offset += MS_BYTES_PER_PAGE*len;
 206                 }
 207                 usb_stor_set_xfer_buf(us, buf, blenByte, srb, TO_XFER_BUF);
 208 exit:
 209                 kfree(buf);
 210         }
 211         return result;
 212 }
 213
 214 /*
 215  * MS_SCSI_Write()
 216  */
 217 int MS_SCSI_Write(struct us_data *us, struct scsi_cmnd *srb)
 218 {
 219         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 220         int result = 0;
 221         PBYTE   Cdb = srb->cmnd;
 222         DWORD bn  = ((Cdb[2] << 24) & 0xff000000) |
 223                         ((Cdb[3] << 16) & 0x00ff0000) |
 224                         ((Cdb[4] << 8) & 0x0000ff00) |
 225                         ((Cdb[5] << 0) & 0x000000ff);
 226         WORD  blen = ((Cdb[7] << 8) & 0xff00)     | ((Cdb[8] << 0) & 0x00ff);
 227         DWORD   blenByte = blen * 0x200;
 228
 229         if (bn > us->bl_num)
 230                 return USB_STOR_TRANSPORT_ERROR;
 231
 232         if (us->MS_Status.IsMSPro) {
 233                 result = ENE_LoadBinCode(us, MSP_RW_PATTERN);
 234                 if (result != USB_STOR_XFER_GOOD) {
 235                         pr_info("Load MSP RW pattern Fail !!\n");
 236                         return USB_STOR_TRANSPORT_ERROR;
 237                 }
 238
 239                 /* set up the command wrapper */
 240                 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 241                 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 242                 bcb->DataTransferLength = blenByte;
 243                 bcb->Flags  = 0x00;
 244                 bcb->CDB[0] = 0xF0;
 245                 bcb->CDB[1] = 0x04;
 246                 bcb->CDB[5] = (BYTE)(bn);
 247                 bcb->CDB[4] = (BYTE)(bn>>8);
 248                 bcb->CDB[3] = (BYTE)(bn>>16);
 249                 bcb->CDB[2] = (BYTE)(bn>>24);
 250
 251                 result = ENE_SendScsiCmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
 252         } else {
 253                 void    *buf;
 254                 int     offset = 0;
 255                 WORD    PhyBlockAddr;
 256                 BYTE    PageNum;
 257                 DWORD   result;
 258                 WORD    len, oldphy, newphy;
 259
 260                 buf = kmalloc(blenByte, GFP_KERNEL);
 261                 if (buf == NULL)
 262                         return USB_STOR_TRANSPORT_ERROR;
 263                 usb_stor_set_xfer_buf(us, buf, blenByte, srb, FROM_XFER_BUF);
 264
 265                 result = ENE_LoadBinCode(us, MS_RW_PATTERN);
 266                 if (result != USB_STOR_XFER_GOOD) {
 267                         pr_info("Load MS RW pattern Fail !!\n");
 268                         result = USB_STOR_TRANSPORT_ERROR;
 269                         goto exit;
 270                 }
 271
 272                 PhyBlockAddr = (WORD)(bn / us->MS_Lib.PagesPerBlock);
 273                 PageNum      = (BYTE)(bn % us->MS_Lib.PagesPerBlock);
 274
 275                 while (1) {
 276                         if (blen > (us->MS_Lib.PagesPerBlock-PageNum))
 277                                 len = us->MS_Lib.PagesPerBlock-PageNum;
 278                         else
 279                                 len = blen;
 280
 281                         oldphy = MS_LibConv2Physical(us, PhyBlockAddr);
 282                         newphy = MS_LibSearchBlockFromLogical(us, PhyBlockAddr);
 283
 284                         result = MS_ReaderCopyBlock(us, oldphy, newphy,
 285                                                         PhyBlockAddr, PageNum,
 286                                                         buf+offset, len);
 287                         if (result != USB_STOR_XFER_GOOD) {
 288                                 pr_info("MS_SCSI_Write --- result = %x\n",
 289                                                                 result);
 290                                 result =  USB_STOR_TRANSPORT_ERROR;
 291                                 goto exit;
 292                         }
 293
 294                         us->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
 295                         MS_LibForceSetLogicalPair(us, PhyBlockAddr, newphy);
 296
 297                         blen -= len;
 298                         if (blen <= 0)
 299                                 break;
 300                         PhyBlockAddr++;
 301                         PageNum = 0;
 302                         offset += MS_BYTES_PER_PAGE*len;
 303                 }
 304 exit:
 305                 kfree(buf);
 306         }
 307         return result;
 308 }
 309
 310 /*
 311  * MS_SCSIIrp()
 312  */
 313 int MS_SCSIIrp(struct us_data *us, struct scsi_cmnd *srb)
 314 {
 315         int    result;
 316
 317         us->SrbStatus = SS_SUCCESS;
 318         switch (srb->cmnd[0]) {
 319         case TEST_UNIT_READY:
 320                 result = MS_SCSI_Test_Unit_Ready(us, srb);
 321                 break; /* 0x00 */
 322         case INQUIRY:
 323                 result = MS_SCSI_Inquiry(us, srb);
 324                 break; /* 0x12 */
 325         case MODE_SENSE:
 326                 result = MS_SCSI_Mode_Sense(us, srb);
 327                 break; /* 0x1A */
 328         case READ_CAPACITY:
 329                 result = MS_SCSI_Read_Capacity(us, srb);
 330                 break; /* 0x25 */
 331         case READ_10:
 332                 result = MS_SCSI_Read(us, srb);
 333                 break; /* 0x28 */
 334         case WRITE_10:
 335                 result = MS_SCSI_Write(us, srb);
 336                 break;  /* 0x2A */
 337         default:
 338                 us->SrbStatus = SS_ILLEGAL_REQUEST;
 339                 result = USB_STOR_TRANSPORT_FAILED;
 340                 break;
 341         }
 342         return result;
 343 }
 344