*/
     host->scsi.phase = PHASE_CONNECTING;
     host->SCpnt = SCpnt;
-    host->scsi.SCp = SCpnt->SCp;
+    host->scsi.SCp = *arm_scsi_pointer(SCpnt);
     host->dma.xfer_setup = 0;
     host->dma.xfer_required = 0;
     host->dma.xfer_done = 0;
 static
 void acornscsi_message(AS_Host *host)
 {
+    struct scsi_pointer *scsi_pointer;
     unsigned char message[16];
     unsigned int msgidx = 0, msglen = 1;
 
         *  the saved data pointer for the current I/O process.
         */
        acornscsi_dma_cleanup(host);
-       host->SCpnt->SCp = host->scsi.SCp;
-       host->SCpnt->SCp.sent_command = 0;
+       scsi_pointer = arm_scsi_pointer(host->SCpnt);
+       *scsi_pointer = host->scsi.SCp;
+       scsi_pointer->sent_command = 0;
        host->scsi.phase = PHASE_MSGIN;
        break;
 
         *  the present command and status areas.'
         */
        acornscsi_dma_cleanup(host);
-       host->scsi.SCp = host->SCpnt->SCp;
+       host->scsi.SCp = *arm_scsi_pointer(host->SCpnt);
        host->scsi.phase = PHASE_MSGIN;
        break;
 
        /*
         * Restore data pointer from SAVED pointers.
         */
-       host->scsi.SCp = host->SCpnt->SCp;
+       host->scsi.SCp = *arm_scsi_pointer(host->SCpnt);
 #if (DEBUG & (DEBUG_QUEUES|DEBUG_DISCON))
        printk(", data pointers: [%p, %X]",
                host->scsi.SCp.ptr, host->scsi.SCp.this_residual);
  */
 static int acornscsi_queuecmd_lck(struct scsi_cmnd *SCpnt)
 {
+    struct scsi_pointer *scsi_pointer = arm_scsi_pointer(SCpnt);
     void (*done)(struct scsi_cmnd *) = scsi_done;
     AS_Host *host = (AS_Host *)SCpnt->device->host->hostdata;
 
 
     SCpnt->host_scribble = NULL;
     SCpnt->result = 0;
-    SCpnt->SCp.phase = (int)acornscsi_datadirection(SCpnt->cmnd[0]);
-    SCpnt->SCp.sent_command = 0;
-    SCpnt->SCp.scsi_xferred = 0;
+    scsi_pointer->phase = (int)acornscsi_datadirection(SCpnt->cmnd[0]);
+    scsi_pointer->sent_command = 0;
+    scsi_pointer->scsi_xferred = 0;
 
     init_SCp(SCpnt);
 
        .cmd_per_lun            = 2,
        .dma_boundary           = PAGE_SIZE - 1,
        .proc_name              = "acornscsi",
+       .cmd_size               = sizeof(struct arm_cmd_priv),
 };
 
 static int acornscsi_probe(struct expansion_card *ec, const struct ecard_id *id)
 
 
 #define BELT_AND_BRACES
 
+struct arm_cmd_priv {
+       struct scsi_pointer scsi_pointer;
+};
+
+static inline struct scsi_pointer *arm_scsi_pointer(struct scsi_cmnd *cmd)
+{
+       struct arm_cmd_priv *acmd = scsi_cmd_priv(cmd);
+
+       return &acmd->scsi_pointer;
+}
+
 /*
  * The scatter-gather list handling.  This contains all
  * the yucky stuff that needs to be fixed properly.
 
 static inline void init_SCp(struct scsi_cmnd *SCpnt)
 {
-       memset(&SCpnt->SCp, 0, sizeof(struct scsi_pointer));
+       struct scsi_pointer *scsi_pointer = arm_scsi_pointer(SCpnt);
+
+       memset(scsi_pointer, 0, sizeof(struct scsi_pointer));
 
        if (scsi_bufflen(SCpnt)) {
                unsigned long len = 0;
 
-               SCpnt->SCp.buffer = scsi_sglist(SCpnt);
-               SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1;
-               SCpnt->SCp.ptr = sg_virt(SCpnt->SCp.buffer);
-               SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
-               SCpnt->SCp.phase = scsi_bufflen(SCpnt);
+               scsi_pointer->buffer = scsi_sglist(SCpnt);
+               scsi_pointer->buffers_residual = scsi_sg_count(SCpnt) - 1;
+               scsi_pointer->ptr = sg_virt(scsi_pointer->buffer);
+               scsi_pointer->this_residual = scsi_pointer->buffer->length;
+               scsi_pointer->phase = scsi_bufflen(SCpnt);
 
 #ifdef BELT_AND_BRACES
                {       /*
                                 * FIXME: Totaly naive fixup. We should abort
                                 * with error
                                 */
-                               SCpnt->SCp.phase =
+                               scsi_pointer->phase =
                                        min_t(unsigned long, len,
                                              scsi_bufflen(SCpnt));
                        }
                }
 #endif
        } else {
-               SCpnt->SCp.ptr = NULL;
-               SCpnt->SCp.this_residual = 0;
-               SCpnt->SCp.phase = 0;
+               scsi_pointer->ptr = NULL;
+               scsi_pointer->this_residual = 0;
+               scsi_pointer->phase = 0;
        }
 }
 
                fas216_log(info, LOG_ERROR, "null buffer passed to "
                           "fas216_starttransfer");
                print_SCp(&info->scsi.SCp, "SCp: ", "\n");
-               print_SCp(&info->SCpnt->SCp, "Cmnd SCp: ", "\n");
+               print_SCp(arm_scsi_pointer(info->SCpnt), "Cmnd SCp: ", "\n");
                return;
        }
 
                /*
                 * Restore data pointer from SAVED data pointer
                 */
-               info->scsi.SCp = info->SCpnt->SCp;
+               info->scsi.SCp = *arm_scsi_pointer(info->SCpnt);
 
                fas216_log(info, LOG_CONNECT, "data pointers: [%p, %X]",
                        info->scsi.SCp.ptr, info->scsi.SCp.this_residual);
 
 static void fas216_parse_message(FAS216_Info *info, unsigned char *message, int msglen)
 {
+       struct scsi_pointer *scsi_pointer;
        int i;
 
        switch (message[0]) {
                 * as required by the SCSI II standard.  These always
                 * point to the start of their respective areas.
                 */
-               info->SCpnt->SCp = info->scsi.SCp;
-               info->SCpnt->SCp.sent_command = 0;
+               scsi_pointer = arm_scsi_pointer(info->SCpnt);
+               *scsi_pointer = info->scsi.SCp;
+               scsi_pointer->sent_command = 0;
                fas216_log(info, LOG_CONNECT | LOG_MESSAGES | LOG_BUFFER,
                        "save data pointers: [%p, %X]",
                        info->scsi.SCp.ptr, info->scsi.SCp.this_residual);
                /*
                 * Restore current data pointer from SAVED data pointer
                 */
-               info->scsi.SCp = info->SCpnt->SCp;
+               info->scsi.SCp = *arm_scsi_pointer(info->SCpnt);
                fas216_log(info, LOG_CONNECT | LOG_MESSAGES | LOG_BUFFER,
                        "restore data pointers: [%p, 0x%x]",
                        info->scsi.SCp.ptr, info->scsi.SCp.this_residual);
         * claim host busy
         */
        info->scsi.phase = PHASE_SELECTION;
-       info->scsi.SCp = SCpnt->SCp;
+       info->scsi.SCp = *arm_scsi_pointer(SCpnt);
        info->SCpnt = SCpnt;
        info->dma.transfer_type = fasdma_none;
 
         * claim host busy
         */
        info->scsi.phase = PHASE_SELECTION;
-       info->scsi.SCp = SCpnt->SCp;
+       info->scsi.SCp = *arm_scsi_pointer(SCpnt);
        info->SCpnt = SCpnt;
        info->dma.transfer_type = fasdma_none;
 
 static void fas216_rq_sns_done(FAS216_Info *info, struct scsi_cmnd *SCpnt,
                               unsigned int result)
 {
+       struct scsi_pointer *scsi_pointer = arm_scsi_pointer(SCpnt);
+
        fas216_log_target(info, LOG_CONNECT, SCpnt->device->id,
                   "request sense complete, result=0x%04x%02x%02x",
-                  result, SCpnt->SCp.Message, SCpnt->SCp.Status);
+                  result, scsi_pointer->Message, scsi_pointer->Status);
 
-       if (result != DID_OK || SCpnt->SCp.Status != SAM_STAT_GOOD)
+       if (result != DID_OK || scsi_pointer->Status != SAM_STAT_GOOD)
                /*
                 * Something went wrong.  Make sure that we don't
                 * have valid data in the sense buffer that could
 static void
 fas216_std_done(FAS216_Info *info, struct scsi_cmnd *SCpnt, unsigned int result)
 {
+       struct scsi_pointer *scsi_pointer = arm_scsi_pointer(SCpnt);
+
        info->stats.fins += 1;
 
        set_host_byte(SCpnt, result);
        fas216_log_target(info, LOG_CONNECT, SCpnt->device->id,
                          "requesting sense");
        init_SCp(SCpnt);
-       SCpnt->SCp.Message = 0;
-       SCpnt->SCp.Status = 0;
+       scsi_pointer->Message = 0;
+       scsi_pointer->Status = 0;
        SCpnt->host_scribble = (void *)fas216_rq_sns_done;
 
        /*
 
 
 /* driver-private data per SCSI command. */
 struct fas216_cmd_priv {
+       /*
+        * @scsi_pointer must be the first member. See also arm_scsi_pointer().
+        */
+       struct scsi_pointer scsi_pointer;
        void (*scsi_done)(struct scsi_cmnd *cmd);
 };