drivers/staging/keucr/init.c

   1 #include <linux/sched.h>
   2 #include <linux/errno.h>
   3 #include <linux/slab.h>
   4
   5 #include <scsi/scsi.h>
   6 #include <scsi/scsi_eh.h>
   7 #include <scsi/scsi_device.h>
   8
   9 #include "usb.h"
  10 #include "scsiglue.h"
  11 #include "transport.h"
  12 #include "init.h"
  13
  14 BYTE IsSSFDCCompliance;
  15 BYTE IsXDCompliance;
  16
  17 /*
  18  * ENE_InitMedia():
  19  */
  20 int ENE_InitMedia(struct us_data *us)
  21 {
  22         int     result;
  23         BYTE    MiscReg03 = 0;
  24
  25         printk(KERN_INFO "--- Init Media ---\n");
  26         result = ENE_Read_BYTE(us, REG_CARD_STATUS, &MiscReg03);
  27         if (result != USB_STOR_XFER_GOOD) {
  28                 printk(KERN_ERR "Read register fail !!\n");
  29                 return USB_STOR_TRANSPORT_ERROR;
  30         }
  31         printk(KERN_INFO "MiscReg03 = %x\n", MiscReg03);
  32
  33         if (MiscReg03 & 0x01) {
  34                 if (!us->SD_Status.Ready) {
  35                         result = ENE_SDInit(us);
  36                         if (result != USB_STOR_XFER_GOOD)
  37                                 return USB_STOR_TRANSPORT_ERROR;
  38                 }
  39         }
  40
  41         if (MiscReg03 & 0x02) {
  42                 if (!us->SM_Status.Ready && !us->MS_Status.Ready) {
  43                         result = ENE_SMInit(us);
  44                         if (result != USB_STOR_XFER_GOOD) {
  45                                 result = ENE_MSInit(us);
  46                                 if (result != USB_STOR_XFER_GOOD)
  47                                         return USB_STOR_TRANSPORT_ERROR;
  48                         }
  49                 }
  50
  51         }
  52         return result;
  53 }
  54
  55 /*
  56  * ENE_Read_BYTE() :
  57  */
  58 int ENE_Read_BYTE(struct us_data *us, WORD index, void *buf)
  59 {
  60         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
  61         int result;
  62
  63         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
  64         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
  65         bcb->DataTransferLength = 0x01;
  66         bcb->Flags                      = 0x80;
  67         bcb->CDB[0]                     = 0xED;
  68         bcb->CDB[2]                     = (BYTE)(index>>8);
  69         bcb->CDB[3]                     = (BYTE)index;
  70
  71         result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
  72         return result;
  73 }
  74
  75 /*
  76  * ENE_SDInit():
  77  */
  78 int ENE_SDInit(struct us_data *us)
  79 {
  80         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
  81         int     result;
  82         BYTE    buf[0x200];
  83
  84         printk(KERN_INFO "transport --- ENE_SDInit\n");
  85         /* SD Init Part-1 */
  86         result = ENE_LoadBinCode(us, SD_INIT1_PATTERN);
  87         if (result != USB_STOR_XFER_GOOD) {
  88                 printk(KERN_ERR "Load SD Init Code Part-1 Fail !!\n");
  89                 return USB_STOR_TRANSPORT_ERROR;
  90         }
  91
  92         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
  93         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
  94         bcb->Flags = 0x80;
  95         bcb->CDB[0] = 0xF2;
  96
  97         result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
  98         if (result != USB_STOR_XFER_GOOD) {
  99                 printk(KERN_ERR "Exection SD Init Code Fail !!\n");
 100                 return USB_STOR_TRANSPORT_ERROR;
 101         }
 102
 103         /* SD Init Part-2 */
 104         result = ENE_LoadBinCode(us, SD_INIT2_PATTERN);
 105         if (result != USB_STOR_XFER_GOOD) {
 106                 printk(KERN_ERR "Load SD Init Code Part-2 Fail !!\n");
 107                 return USB_STOR_TRANSPORT_ERROR;
 108         }
 109
 110         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 111         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 112         bcb->DataTransferLength = 0x200;
 113         bcb->Flags                      = 0x80;
 114         bcb->CDB[0]                     = 0xF1;
 115
 116         result = ENE_SendScsiCmd(us, FDIR_READ, &buf, 0);
 117         if (result != USB_STOR_XFER_GOOD) {
 118                 printk(KERN_ERR "Exection SD Init Code Fail !!\n");
 119                 return USB_STOR_TRANSPORT_ERROR;
 120         }
 121
 122         us->SD_Status =  *(PSD_STATUS)&buf[0];
 123         if (us->SD_Status.Insert && us->SD_Status.Ready) {
 124                 ENE_ReadSDReg(us, (PBYTE)&buf);
 125                 printk(KERN_INFO "Insert     = %x\n", us->SD_Status.Insert);
 126                 printk(KERN_INFO "Ready      = %x\n", us->SD_Status.Ready);
 127                 printk(KERN_INFO "IsMMC      = %x\n", us->SD_Status.IsMMC);
 128                 printk(KERN_INFO "HiCapacity = %x\n", us->SD_Status.HiCapacity);
 129                 printk(KERN_INFO "HiSpeed    = %x\n", us->SD_Status.HiSpeed);
 130                 printk(KERN_INFO "WtP        = %x\n", us->SD_Status.WtP);
 131         } else {
 132                 printk(KERN_ERR "SD Card Not Ready --- %x\n", buf[0]);
 133                 return USB_STOR_TRANSPORT_ERROR;
 134         }
 135         return USB_STOR_TRANSPORT_GOOD;
 136 }
 137
 138 /*
 139  * ENE_MSInit():
 140  */
 141 int ENE_MSInit(struct us_data *us)
 142 {
 143         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 144         int     result;
 145         BYTE    buf[0x200];
 146         WORD    MSP_BlockSize, MSP_UserAreaBlocks;
 147
 148         printk(KERN_INFO "transport --- ENE_MSInit\n");
 149         result = ENE_LoadBinCode(us, MS_INIT_PATTERN);
 150         if (result != USB_STOR_XFER_GOOD) {
 151                 printk(KERN_ERR "Load MS Init Code Fail !!\n");
 152                 return USB_STOR_TRANSPORT_ERROR;
 153         }
 154
 155         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 156         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 157         bcb->DataTransferLength = 0x200;
 158         bcb->Flags                      = 0x80;
 159         bcb->CDB[0]                     = 0xF1;
 160         bcb->CDB[1]                     = 0x01;
 161
 162         result = ENE_SendScsiCmd(us, FDIR_READ, &buf, 0);
 163         if (result != USB_STOR_XFER_GOOD) {
 164                 printk(KERN_ERR "Exection MS Init Code Fail !!\n");
 165                 return USB_STOR_TRANSPORT_ERROR;
 166         }
 167
 168         us->MS_Status = *(PMS_STATUS)&buf[0];
 169
 170         if (us->MS_Status.Insert && us->MS_Status.Ready) {
 171                 printk(KERN_INFO "Insert     = %x\n", us->MS_Status.Insert);
 172                 printk(KERN_INFO "Ready      = %x\n", us->MS_Status.Ready);
 173                 printk(KERN_INFO "IsMSPro    = %x\n", us->MS_Status.IsMSPro);
 174                 printk(KERN_INFO "IsMSPHG    = %x\n", us->MS_Status.IsMSPHG);
 175                 printk(KERN_INFO "WtP        = %x\n", us->MS_Status.WtP);
 176                 if (us->MS_Status.IsMSPro) {
 177                         MSP_BlockSize      = (buf[6] << 8) | buf[7];
 178                         MSP_UserAreaBlocks = (buf[10] << 8) | buf[11];
 179                         us->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
 180                 } else {
 181                         MS_CardInit(us);
 182                 }
 183                 printk(KERN_INFO "MS Init Code OK !!\n");
 184         } else {
 185                 printk(KERN_INFO "MS Card Not Ready --- %x\n", buf[0]);
 186                 return USB_STOR_TRANSPORT_ERROR;
 187         }
 188
 189         return USB_STOR_TRANSPORT_GOOD;
 190 }
 191
 192 /*
 193  *ENE_SMInit()
 194  */
 195 int ENE_SMInit(struct us_data *us)
 196 {
 197         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 198         int     result;
 199         BYTE    buf[0x200];
 200
 201         printk(KERN_INFO "transport --- ENE_SMInit\n");
 202
 203         result = ENE_LoadBinCode(us, SM_INIT_PATTERN);
 204         if (result != USB_STOR_XFER_GOOD) {
 205                 printk(KERN_INFO "Load SM Init Code Fail !!\n");
 206                 return USB_STOR_TRANSPORT_ERROR;
 207         }
 208
 209         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 210         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 211         bcb->DataTransferLength = 0x200;
 212         bcb->Flags                      = 0x80;
 213         bcb->CDB[0]                     = 0xF1;
 214         bcb->CDB[1]                     = 0x01;
 215
 216         result = ENE_SendScsiCmd(us, FDIR_READ, &buf, 0);
 217         if (result != USB_STOR_XFER_GOOD) {
 218                 printk(KERN_ERR
 219                        "Exection SM Init Code Fail !! result = %x\n", result);
 220                 return USB_STOR_TRANSPORT_ERROR;
 221         }
 222
 223         us->SM_Status = *(PSM_STATUS)&buf[0];
 224
 225         us->SM_DeviceID = buf[1];
 226         us->SM_CardID   = buf[2];
 227
 228         if (us->SM_Status.Insert && us->SM_Status.Ready) {
 229                 printk(KERN_INFO "Insert     = %x\n", us->SM_Status.Insert);
 230                 printk(KERN_INFO "Ready      = %x\n", us->SM_Status.Ready);
 231                 printk(KERN_INFO "WtP        = %x\n", us->SM_Status.WtP);
 232                 printk(KERN_INFO "DeviceID   = %x\n", us->SM_DeviceID);
 233                 printk(KERN_INFO "CardID     = %x\n", us->SM_CardID);
 234                 MediaChange = 1;
 235                 Check_D_MediaFmt(us);
 236         } else {
 237                 printk(KERN_ERR "SM Card Not Ready --- %x\n", buf[0]);
 238                 return USB_STOR_TRANSPORT_ERROR;
 239         }
 240
 241         return USB_STOR_TRANSPORT_GOOD;
 242 }
 243
 244 /*
 245  * ENE_ReadSDReg()
 246  */
 247 int ENE_ReadSDReg(struct us_data *us, u8 *RdBuf)
 248 {
 249         WORD    tmpreg;
 250         DWORD   reg4b;
 251
 252         /* printk(KERN_INFO "transport --- ENE_ReadSDReg\n"); */
 253         reg4b = *(PDWORD)&RdBuf[0x18];
 254         us->SD_READ_BL_LEN = (BYTE)((reg4b >> 8) & 0x0f);
 255
 256         tmpreg = (WORD) reg4b;
 257         reg4b = *(PDWORD)(&RdBuf[0x14]);
 258         if (us->SD_Status.HiCapacity && !us->SD_Status.IsMMC)
 259                 us->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
 260
 261         us->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (WORD)(reg4b >> 22);
 262         us->SD_C_SIZE_MULT = (BYTE)(reg4b >> 7)  & 0x07;
 263         if (us->SD_Status.HiCapacity && us->SD_Status.IsMMC)
 264                 us->HC_C_SIZE = *(PDWORD)(&RdBuf[0x100]);
 265
 266         if (us->SD_READ_BL_LEN > SD_BLOCK_LEN) {
 267                 us->SD_Block_Mult =
 268                         1 << (us->SD_READ_BL_LEN - SD_BLOCK_LEN);
 269                 us->SD_READ_BL_LEN = SD_BLOCK_LEN;
 270         } else {
 271                 us->SD_Block_Mult = 1;
 272         }
 273         return USB_STOR_TRANSPORT_GOOD;
 274 }
 275
 276 /*
 277  * ENE_LoadBinCode()
 278  */
 279 int ENE_LoadBinCode(struct us_data *us, BYTE flag)
 280 {
 281         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 282         int result;
 283         /* void *buf; */
 284         PBYTE buf;
 285
 286         /* printk(KERN_INFO "transport --- ENE_LoadBinCode\n"); */
 287         if (us->BIN_FLAG == flag)
 288                 return USB_STOR_TRANSPORT_GOOD;
 289
 290         buf = kmalloc(0x800, GFP_KERNEL);
 291         if (buf == NULL)
 292                 return USB_STOR_TRANSPORT_ERROR;
 293         switch (flag) {
 294         /* For SD */
 295         case SD_INIT1_PATTERN:
 296                 printk(KERN_INFO "SD_INIT1_PATTERN\n");
 297                 memcpy(buf, SD_Init1, 0x800);
 298                 break;
 299         case SD_INIT2_PATTERN:
 300                 printk(KERN_INFO "SD_INIT2_PATTERN\n");
 301                 memcpy(buf, SD_Init2, 0x800);
 302                 break;
 303         case SD_RW_PATTERN:
 304                 printk(KERN_INFO "SD_RW_PATTERN\n");
 305                 memcpy(buf, SD_Rdwr, 0x800);
 306                 break;
 307         /* For MS */
 308         case MS_INIT_PATTERN:
 309                 printk(KERN_INFO "MS_INIT_PATTERN\n");
 310                 memcpy(buf, MS_Init, 0x800);
 311                 break;
 312         case MSP_RW_PATTERN:
 313                 printk(KERN_INFO "MSP_RW_PATTERN\n");
 314                 memcpy(buf, MSP_Rdwr, 0x800);
 315                 break;
 316         case MS_RW_PATTERN:
 317                 printk(KERN_INFO "MS_RW_PATTERN\n");
 318                 memcpy(buf, MS_Rdwr, 0x800);
 319                 break;
 320         /* For SS */
 321         case SM_INIT_PATTERN:
 322                 printk(KERN_INFO "SM_INIT_PATTERN\n");
 323                 memcpy(buf, SM_Init, 0x800);
 324                 break;
 325         case SM_RW_PATTERN:
 326                 printk(KERN_INFO "SM_RW_PATTERN\n");
 327                 memcpy(buf, SM_Rdwr, 0x800);
 328                 break;
 329         }
 330
 331         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 332         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 333         bcb->DataTransferLength = 0x800;
 334         bcb->Flags = 0x00;
 335         bcb->CDB[0] = 0xEF;
 336
 337         result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
 338
 339         kfree(buf);
 340         us->BIN_FLAG = flag;
 341         return result;
 342 }
 343
 344 /*
 345  * ENE_SendScsiCmd():
 346  */
 347 int ENE_SendScsiCmd(struct us_data *us, BYTE fDir, void *buf, int use_sg)
 348 {
 349         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 350         struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
 351
 352         int result;
 353         unsigned int transfer_length = bcb->DataTransferLength,
 354                      cswlen = 0, partial = 0;
 355         unsigned int residue;
 356
 357         /* printk(KERN_INFO "transport --- ENE_SendScsiCmd\n"); */
 358         /* send cmd to out endpoint */
 359         result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
 360                                             bcb, US_BULK_CB_WRAP_LEN, NULL);
 361         if (result != USB_STOR_XFER_GOOD) {
 362                 printk(KERN_ERR "send cmd to out endpoint fail ---\n");
 363                 return USB_STOR_TRANSPORT_ERROR;
 364         }
 365
 366         if (buf) {
 367                 unsigned int pipe = fDir;
 368
 369                 if (fDir == FDIR_READ)
 370                         pipe = us->recv_bulk_pipe;
 371                 else
 372                         pipe = us->send_bulk_pipe;
 373
 374                 /* Bulk */
 375                 if (use_sg)
 376                         result = usb_stor_bulk_srb(us, pipe, us->srb);
 377                 else
 378                         result = usb_stor_bulk_transfer_sg(us, pipe, buf,
 379                                                 transfer_length, 0, &partial);
 380                 if (result != USB_STOR_XFER_GOOD) {
 381                         printk(KERN_ERR "data transfer fail ---\n");
 382                         return USB_STOR_TRANSPORT_ERROR;
 383                 }
 384         }
 385
 386         /* Get CSW for device status */
 387         result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
 388                                                 US_BULK_CS_WRAP_LEN, &cswlen);
 389
 390         if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
 391                 printk(KERN_WARNING "Received 0-length CSW; retrying...\n");
 392                 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
 393                                         bcs, US_BULK_CS_WRAP_LEN, &cswlen);
 394         }
 395
 396         if (result == USB_STOR_XFER_STALLED) {
 397                 /* get the status again */
 398                 printk(KERN_WARNING "Attempting to get CSW (2nd try)...\n");
 399                 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
 400                                                 bcs, US_BULK_CS_WRAP_LEN, NULL);
 401         }
 402
 403         if (result != USB_STOR_XFER_GOOD)
 404                 return USB_STOR_TRANSPORT_ERROR;
 405
 406         /* check bulk status */
 407         residue = le32_to_cpu(bcs->Residue);
 408
 409         /*
 410          * try to compute the actual residue, based on how much data
 411          * was really transferred and what the device tells us
 412          */
 413         if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
 414                 residue = min(residue, transfer_length);
 415                 scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
 416                                                         (int) residue));
 417         }
 418
 419         if (bcs->Status != US_BULK_STAT_OK)
 420                 return USB_STOR_TRANSPORT_ERROR;
 421
 422         return USB_STOR_TRANSPORT_GOOD;
 423 }
 424
 425 /*
 426  * ENE_Read_Data()
 427  */
 428 int ENE_Read_Data(struct us_data *us, void *buf, unsigned int length)
 429 {
 430         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 431         struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
 432         int result;
 433
 434         /* printk(KERN_INFO "transport --- ENE_Read_Data\n"); */
 435         /* set up the command wrapper */
 436         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 437         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 438         bcb->DataTransferLength = length;
 439         bcb->Flags = 0x80;
 440         bcb->CDB[0] = 0xED;
 441         bcb->CDB[2] = 0xFF;
 442         bcb->CDB[3] = 0x81;
 443
 444         /* send cmd to out endpoint */
 445         result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb,
 446                                                 US_BULK_CB_WRAP_LEN, NULL);
 447         if (result != USB_STOR_XFER_GOOD)
 448                 return USB_STOR_TRANSPORT_ERROR;
 449
 450         /* R/W data */
 451         result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
 452                                                 buf, length, NULL);
 453         if (result != USB_STOR_XFER_GOOD)
 454                 return USB_STOR_TRANSPORT_ERROR;
 455
 456         /* Get CSW for device status */
 457         result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
 458                                                 US_BULK_CS_WRAP_LEN, NULL);
 459         if (result != USB_STOR_XFER_GOOD)
 460                 return USB_STOR_TRANSPORT_ERROR;
 461         if (bcs->Status != US_BULK_STAT_OK)
 462                 return USB_STOR_TRANSPORT_ERROR;
 463
 464         return USB_STOR_TRANSPORT_GOOD;
 465 }
 466
 467 /*
 468  * ENE_Write_Data():
 469  */
 470 int ENE_Write_Data(struct us_data *us, void *buf, unsigned int length)
 471 {
 472         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 473         struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
 474         int result;
 475
 476         /* printk("transport --- ENE_Write_Data\n"); */
 477         /* set up the command wrapper */
 478         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 479         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 480         bcb->DataTransferLength = length;
 481         bcb->Flags = 0x00;
 482         bcb->CDB[0] = 0xEE;
 483         bcb->CDB[2] = 0xFF;
 484         bcb->CDB[3] = 0x81;
 485
 486         /* send cmd to out endpoint */
 487         result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb,
 488                                                 US_BULK_CB_WRAP_LEN, NULL);
 489         if (result != USB_STOR_XFER_GOOD)
 490                 return USB_STOR_TRANSPORT_ERROR;
 491
 492         /* R/W data */
 493         result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
 494                                                 buf, length, NULL);
 495         if (result != USB_STOR_XFER_GOOD)
 496                 return USB_STOR_TRANSPORT_ERROR;
 497
 498         /* Get CSW for device status */
 499         result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
 500                                                 US_BULK_CS_WRAP_LEN, NULL);
 501         if (result != USB_STOR_XFER_GOOD)
 502                 return USB_STOR_TRANSPORT_ERROR;
 503         if (bcs->Status != US_BULK_STAT_OK)
 504                 return USB_STOR_TRANSPORT_ERROR;
 505
 506         return USB_STOR_TRANSPORT_GOOD;
 507 }
 508
 509 /*
 510  * usb_stor_print_cmd():
 511  */
 512 void usb_stor_print_cmd(struct scsi_cmnd *srb)
 513 {
 514         PBYTE   Cdb = srb->cmnd;
 515         DWORD   cmd = Cdb[0];
 516         DWORD   bn  =   ((Cdb[2] << 24) & 0xff000000) |
 517                         ((Cdb[3] << 16) & 0x00ff0000) |
 518                         ((Cdb[4] << 8) & 0x0000ff00) |
 519                         ((Cdb[5] << 0) & 0x000000ff);
 520         WORD    blen = ((Cdb[7] << 8) & 0xff00) | ((Cdb[8] << 0) & 0x00ff);
 521
 522         switch (cmd) {
 523         case TEST_UNIT_READY:
 524                 /* printk(KERN_INFO
 525                          "scsi cmd %X --- SCSIOP_TEST_UNIT_READY\n", cmd); */
 526                 break;
 527         case INQUIRY:
 528                 printk(KERN_INFO "scsi cmd %X --- SCSIOP_INQUIRY\n", cmd);
 529                 break;
 530         case MODE_SENSE:
 531                 printk(KERN_INFO "scsi cmd %X --- SCSIOP_MODE_SENSE\n", cmd);
 532                 break;
 533         case START_STOP:
 534                 printk(KERN_INFO "scsi cmd %X --- SCSIOP_START_STOP\n", cmd);
 535                 break;
 536         case READ_CAPACITY:
 537                 printk(KERN_INFO "scsi cmd %X --- SCSIOP_READ_CAPACITY\n", cmd);
 538                 break;
 539         case READ_10:
 540                 /*  printk(KERN_INFO
 541                            "scsi cmd %X --- SCSIOP_READ,bn = %X, blen = %X\n"
 542                            ,cmd, bn, blen); */
 543                 break;
 544         case WRITE_10:
 545                 /* printk(KERN_INFO
 546                           "scsi cmd %X --- SCSIOP_WRITE,
 547                           bn = %X, blen = %X\n" , cmd, bn, blen); */
 548                 break;
 549         case ALLOW_MEDIUM_REMOVAL:
 550                 printk(KERN_INFO
 551                         "scsi cmd %X --- SCSIOP_ALLOW_MEDIUM_REMOVAL\n", cmd);
 552                 break;
 553         default:
 554                 printk(KERN_INFO "scsi cmd %X --- Other cmd\n", cmd);
 555                 break;
 556         }
 557         bn = 0;
 558         blen = 0;
 559 }
 560
 561