release/src-rt-6.x.4708/linux/linux-2.6.36/arch/powerpc/platforms/cell/spufs/spu_save.c

   1 /*
   2  * spu_save.c
   3  *
   4  * (C) Copyright IBM Corp. 2005
   5  *
   6  * SPU-side context save sequence outlined in
   7  * Synergistic Processor Element Book IV
   8  *
   9  * Author: Mark Nutter <mnutter@us.ibm.com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2, or (at your option)
  14  * any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  *
  25  */
  26
  27
  28 #ifndef LS_SIZE
  29 #define LS_SIZE                 0x40000 /* 256K (in bytes) */
  30 #endif
  31
  32 typedef unsigned int u32;
  33 typedef unsigned long long u64;
  34
  35 #include <spu_intrinsics.h>
  36 #include <asm/spu_csa.h>
  37 #include "spu_utils.h"
  38
  39 static inline void save_event_mask(void)
  40 {
  41         unsigned int offset;
  42
  43         /* Save, Step 2:
  44          *    Read the SPU_RdEventMsk channel and save to the LSCSA.
  45          */
  46         offset = LSCSA_QW_OFFSET(event_mask);
  47         regs_spill[offset].slot[0] = spu_readch(SPU_RdEventMask);
  48 }
  49
  50 static inline void save_tag_mask(void)
  51 {
  52         unsigned int offset;
  53
  54         /* Save, Step 3:
  55          *    Read the SPU_RdTagMsk channel and save to the LSCSA.
  56          */
  57         offset = LSCSA_QW_OFFSET(tag_mask);
  58         regs_spill[offset].slot[0] = spu_readch(MFC_RdTagMask);
  59 }
  60
  61 static inline void save_upper_240kb(addr64 lscsa_ea)
  62 {
  63         unsigned int ls = 16384;
  64         unsigned int list = (unsigned int)&dma_list[0];
  65         unsigned int size = sizeof(dma_list);
  66         unsigned int tag_id = 0;
  67         unsigned int cmd = 0x24;        /* PUTL */
  68
  69         /* Save, Step 7:
  70          *    Enqueue the PUTL command (tag 0) to the MFC SPU command
  71          *    queue to transfer the remaining 240 kb of LS to CSA.
  72          */
  73         spu_writech(MFC_LSA, ls);
  74         spu_writech(MFC_EAH, lscsa_ea.ui[0]);
  75         spu_writech(MFC_EAL, list);
  76         spu_writech(MFC_Size, size);
  77         spu_writech(MFC_TagID, tag_id);
  78         spu_writech(MFC_Cmd, cmd);
  79 }
  80
  81 static inline void save_fpcr(void)
  82 {
  83         // vector unsigned int fpcr;
  84         unsigned int offset;
  85
  86         /* Save, Step 9:
  87          *    Issue the floating-point status and control register
  88          *    read instruction, and save to the LSCSA.
  89          */
  90         offset = LSCSA_QW_OFFSET(fpcr);
  91         regs_spill[offset].v = spu_mffpscr();
  92 }
  93
  94 static inline void save_decr(void)
  95 {
  96         unsigned int offset;
  97
  98         /* Save, Step 10:
  99          *    Read and save the SPU_RdDec channel data to
 100          *    the LSCSA.
 101          */
 102         offset = LSCSA_QW_OFFSET(decr);
 103         regs_spill[offset].slot[0] = spu_readch(SPU_RdDec);
 104 }
 105
 106 static inline void save_srr0(void)
 107 {
 108         unsigned int offset;
 109
 110         /* Save, Step 11:
 111          *    Read and save the SPU_WSRR0 channel data to
 112          *    the LSCSA.
 113          */
 114         offset = LSCSA_QW_OFFSET(srr0);
 115         regs_spill[offset].slot[0] = spu_readch(SPU_RdSRR0);
 116 }
 117
 118 static inline void spill_regs_to_mem(addr64 lscsa_ea)
 119 {
 120         unsigned int ls = (unsigned int)&regs_spill[0];
 121         unsigned int size = sizeof(regs_spill);
 122         unsigned int tag_id = 0;
 123         unsigned int cmd = 0x20;        /* PUT */
 124
 125         /* Save, Step 13:
 126          *    Enqueue a PUT command (tag 0) to send the LSCSA
 127          *    to the CSA.
 128          */
 129         spu_writech(MFC_LSA, ls);
 130         spu_writech(MFC_EAH, lscsa_ea.ui[0]);
 131         spu_writech(MFC_EAL, lscsa_ea.ui[1]);
 132         spu_writech(MFC_Size, size);
 133         spu_writech(MFC_TagID, tag_id);
 134         spu_writech(MFC_Cmd, cmd);
 135 }
 136
 137 static inline void enqueue_sync(addr64 lscsa_ea)
 138 {
 139         unsigned int tag_id = 0;
 140         unsigned int cmd = 0xCC;
 141
 142         /* Save, Step 14:
 143          *    Enqueue an MFC_SYNC command (tag 0).
 144          */
 145         spu_writech(MFC_TagID, tag_id);
 146         spu_writech(MFC_Cmd, cmd);
 147 }
 148
 149 static inline void save_complete(void)
 150 {
 151         /* Save, Step 18:
 152          *    Issue a stop-and-signal instruction indicating
 153          *    "save complete".  Note: This function will not
 154          *    return!!
 155          */
 156         spu_stop(SPU_SAVE_COMPLETE);
 157 }
 158
 159 /**
 160  * main - entry point for SPU-side context save.
 161  *
 162  * This code deviates from the documented sequence as follows:
 163  *
 164  *      1. The EA for LSCSA is passed from PPE in the
 165  *         signal notification channels.
 166  *      2. All 128 registers are saved by crt0.o.
 167  */
 168 int main()
 169 {
 170         addr64 lscsa_ea;
 171
 172         lscsa_ea.ui[0] = spu_readch(SPU_RdSigNotify1);
 173         lscsa_ea.ui[1] = spu_readch(SPU_RdSigNotify2);
 174
 175         /* Step 1: done by exit(). */
 176         save_event_mask();      /* Step 2.  */
 177         save_tag_mask();        /* Step 3.  */
 178         set_event_mask();       /* Step 4.  */
 179         set_tag_mask();         /* Step 5.  */
 180         build_dma_list(lscsa_ea);       /* Step 6.  */
 181         save_upper_240kb(lscsa_ea);     /* Step 7.  */
 182         /* Step 8: done by exit(). */
 183         save_fpcr();            /* Step 9.  */
 184         save_decr();            /* Step 10. */
 185         save_srr0();            /* Step 11. */
 186         enqueue_putllc(lscsa_ea);       /* Step 12. */
 187         spill_regs_to_mem(lscsa_ea);    /* Step 13. */
 188         enqueue_sync(lscsa_ea); /* Step 14. */
 189         set_tag_update();       /* Step 15. */
 190         read_tag_status();      /* Step 16. */
 191         read_llar_status();     /* Step 17. */
 192         save_complete();        /* Step 18. */
 193
 194         return 0;
 195 }