}
 
 static int
-ch_do_scsi(scsi_changer *ch, unsigned char *cmd,
+ch_do_scsi(scsi_changer *ch, unsigned char *cmd, int cmd_len,
           void *buffer, unsigned buflength,
           enum dma_data_direction direction)
 {
        errno = 0;
        if (debug) {
                DPRINTK("command: ");
-               __scsi_print_command(cmd);
+               __scsi_print_command(cmd, cmd_len);
        }
 
        result = scsi_execute_req(ch->device, cmd, direction, buffer,
        cmd[3] = elem        & 0xff;
        cmd[5] = 1;
        cmd[9] = 255;
-       if (0 == (result = ch_do_scsi(ch, cmd, buffer, 256, DMA_FROM_DEVICE))) {
+       if (0 == (result = ch_do_scsi(ch, cmd, 12,
+                                     buffer, 256, DMA_FROM_DEVICE))) {
                if (((buffer[16] << 8) | buffer[17]) != elem) {
                        DPRINTK("asked for element 0x%02x, got 0x%02x\n",
                                elem,(buffer[16] << 8) | buffer[17]);
        memset(cmd,0,sizeof(cmd));
        cmd[0] = INITIALIZE_ELEMENT_STATUS;
        cmd[1] = (ch->device->lun & 0x7) << 5;
-       err = ch_do_scsi(ch, cmd, NULL, 0, DMA_NONE);
+       err = ch_do_scsi(ch, cmd, 6, NULL, 0, DMA_NONE);
        VPRINTK(KERN_INFO, "... finished\n");
        return err;
 }
        cmd[1] = (ch->device->lun & 0x7) << 5;
        cmd[2] = 0x1d;
        cmd[4] = 255;
-       result = ch_do_scsi(ch, cmd, buffer, 255, DMA_FROM_DEVICE);
+       result = ch_do_scsi(ch, cmd, 10, buffer, 255, DMA_FROM_DEVICE);
        if (0 != result) {
                cmd[1] |= (1<<3);
-               result  = ch_do_scsi(ch, cmd, buffer, 255, DMA_FROM_DEVICE);
+               result  = ch_do_scsi(ch, cmd, 10, buffer, 255, DMA_FROM_DEVICE);
        }
        if (0 == result) {
                ch->firsts[CHET_MT] =
        cmd[4]  = (elem  >> 8) & 0xff;
        cmd[5]  =  elem        & 0xff;
        cmd[8]  = rotate ? 1 : 0;
-       return ch_do_scsi(ch, cmd, NULL, 0, DMA_NONE);
+       return ch_do_scsi(ch, cmd, 10, NULL, 0, DMA_NONE);
 }
 
 static int
        cmd[6]  = (dest  >> 8) & 0xff;
        cmd[7]  =  dest        & 0xff;
        cmd[10] = rotate ? 1 : 0;
-       return ch_do_scsi(ch, cmd, NULL,0, DMA_NONE);
+       return ch_do_scsi(ch, cmd, 12, NULL,0, DMA_NONE);
 }
 
 static int
        cmd[9]  =  dest2       & 0xff;
        cmd[10] = (rotate1 ? 1 : 0) | (rotate2 ? 2 : 0);
 
-       return ch_do_scsi(ch, cmd, NULL,0, DMA_NONE);
+       return ch_do_scsi(ch, cmd, 12, NULL, 0, DMA_NONE);
 }
 
 static void
        memcpy(buffer,tag,32);
        ch_check_voltag(buffer);
 
-       result = ch_do_scsi(ch, cmd, buffer, 256, DMA_TO_DEVICE);
+       result = ch_do_scsi(ch, cmd, 12, buffer, 256, DMA_TO_DEVICE);
        kfree(buffer);
        return result;
 }
                ch_cmd[5] = 1;
                ch_cmd[9] = 255;
 
-               result = ch_do_scsi(ch, ch_cmd, buffer, 256, DMA_FROM_DEVICE);
+               result = ch_do_scsi(ch, ch_cmd, 12,
+                                   buffer, 256, DMA_FROM_DEVICE);
                if (!result) {
                        cge.cge_status = buffer[18];
                        cge.cge_flags = 0;
 
        return true;
 }
 
-/* attempt to guess cdb length if cdb_len==0 . No trailing linefeed. */
-static void print_opcode_name(unsigned char * cdbp, int cdb_len)
+static void print_opcode_name(const unsigned char *cdbp, size_t cdb_len)
 {
-       int sa, len, cdb0;
+       int sa, cdb0;
        const char *cdb_name = NULL, *sa_name = NULL;
 
        cdb0 = cdbp[0];
        if (cdb0 == VARIABLE_LENGTH_CMD) {
-               len = scsi_varlen_cdb_length(cdbp);
-               if (len < 10) {
-                       printk("short variable length command, "
-                              "len=%d ext_len=%d", len, cdb_len);
+               if (cdb_len < 10) {
+                       printk("short variable length command, len=%zu",
+                              cdb_len);
                        return;
                }
                sa = (cdbp[8] << 8) + cdbp[9];
-       } else {
+       } else
                sa = cdbp[1] & 0x1f;
-               len = cdb_len;
-       }
 
        if (!scsi_opcode_sa_name(cdb0, sa, &cdb_name, &sa_name)) {
                if (cdb_name)
                        printk("%s, sa=0x%x", cdb_name, sa);
                else
                        printk("cdb[0]=0x%x, sa=0x%x", cdb0, sa);
-
-               if (cdb_len > 0 && len != cdb_len)
-                       printk(", in_cdb_len=%d, ext_len=%d", len, cdb_len);
        }
 }
 
-void __scsi_print_command(unsigned char *cdb)
+void __scsi_print_command(const unsigned char *cdb, size_t cdb_len)
 {
        int k, len;
 
-       print_opcode_name(cdb, 0);
+       print_opcode_name(cdb, cdb_len);
        len = scsi_command_size(cdb);
+       if (cdb_len < len)
+               len = cdb_len;
        /* print out all bytes in cdb */
        for (k = 0; k < len; ++k)
                printk(" %02x", cdb[k]);