SAFE public projects git trees. - safe/jmp/linux-2.6/blob - arch/blackfin/mm/isram-driver.c

   1 /*
   2  * Description: Instruction SRAM accessor functions for the Blackfin
   3  *
   4  * Copyright 2008 Analog Devices Inc.
   5  *
   6  * Bugs: Enter bugs at http://blackfin.uclinux.org/
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, see the file COPYING, or write
  15  * to the Free Software Foundation, Inc.,
  16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19 #define pr_fmt(fmt) "isram: " fmt
  20
  21 #include <linux/module.h>
  22 #include <linux/kernel.h>
  23 #include <linux/types.h>
  24 #include <linux/spinlock.h>
  25 #include <linux/sched.h>
  26
  27 #include <asm/blackfin.h>
  28 #include <asm/dma.h>
  29
  30 /*
  31  * IMPORTANT WARNING ABOUT THESE FUNCTIONS
  32  *
  33  * The emulator will not function correctly if a write command is left in
  34  * ITEST_COMMAND or DTEST_COMMAND AND access to cache memory is needed by
  35  * the emulator. To avoid such problems, ensure that both ITEST_COMMAND
  36  * and DTEST_COMMAND are zero when exiting these functions.
  37  */
  38
  39
  40 /*
  41  * On the Blackfin, L1 instruction sram (which operates at core speeds) can not
  42  * be accessed by a normal core load, so we need to go through a few hoops to
  43  * read/write it.
  44  * To try to make it easier - we export a memcpy interface, where either src or
  45  * dest can be in this special L1 memory area.
  46  * The low level read/write functions should not be exposed to the rest of the
  47  * kernel, since they operate on 64-bit data, and need specific address alignment
  48  */
  49
  50 static DEFINE_SPINLOCK(dtest_lock);
  51
  52 /* Takes a void pointer */
  53 #define IADDR2DTEST(x) \
  54         ({ unsigned long __addr = (unsigned long)(x); \
  55                 (__addr & 0x47F8)        | /* address bits 14 & 10:3 */ \
  56                 (__addr & 0x0800) << 15  | /* address bit  11        */ \
  57                 (__addr  & 0x3000) << 4  | /* address bits 13:12     */ \
  58                 (__addr  & 0x8000) << 8  | /* address bit  15        */ \
  59                 (0x1000004);               /* isram access           */ \
  60         })
  61
  62 /* Takes a pointer, and returns the offset (in bits) which things should be shifted */
  63 #define ADDR2OFFSET(x) ((((unsigned long)(x)) & 0x7) * 8)
  64
  65 /* Takes a pointer, determines if it is the last byte in the isram 64-bit data type */
  66 #define ADDR2LAST(x) ((((unsigned long)x) & 0x7) == 0x7)
  67
  68 static void isram_write(const void *addr, uint64_t data)
  69 {
  70         uint32_t cmd;
  71         unsigned long flags;
  72
  73         if (addr >= (void *)(L1_CODE_START + L1_CODE_LENGTH))
  74                 return;
  75
  76         cmd = IADDR2DTEST(addr) | 1;             /* write */
  77
  78         /*
  79          * Writes to DTEST_DATA[0:1] need to be atomic with write to DTEST_COMMAND
  80          * While in exception context - atomicity is guaranteed or double fault
  81          */
  82         spin_lock_irqsave(&dtest_lock, flags);
  83
  84         bfin_write_DTEST_DATA0(data & 0xFFFFFFFF);
  85         bfin_write_DTEST_DATA1(data >> 32);
  86
  87         /* use the builtin, since interrupts are already turned off */
  88         __builtin_bfin_csync();
  89         bfin_write_DTEST_COMMAND(cmd);
  90         __builtin_bfin_csync();
  91
  92         bfin_write_DTEST_COMMAND(0);
  93         __builtin_bfin_csync();
  94
  95         spin_unlock_irqrestore(&dtest_lock, flags);
  96 }
  97
  98 static uint64_t isram_read(const void *addr)
  99 {
 100         uint32_t cmd;
 101         unsigned long flags;
 102         uint64_t ret;
 103
 104         if (addr > (void *)(L1_CODE_START + L1_CODE_LENGTH))
 105                 return 0;
 106
 107         cmd = IADDR2DTEST(addr) | 0;              /* read */
 108
 109         /*
 110          * Reads of DTEST_DATA[0:1] need to be atomic with write to DTEST_COMMAND
 111          * While in exception context - atomicity is guaranteed or double fault
 112          */
 113         spin_lock_irqsave(&dtest_lock, flags);
 114         /* use the builtin, since interrupts are already turned off */
 115         __builtin_bfin_csync();
 116         bfin_write_DTEST_COMMAND(cmd);
 117         __builtin_bfin_csync();
 118         ret = bfin_read_DTEST_DATA0() | ((uint64_t)bfin_read_DTEST_DATA1() << 32);
 119
 120         bfin_write_DTEST_COMMAND(0);
 121         __builtin_bfin_csync();
 122         spin_unlock_irqrestore(&dtest_lock, flags);
 123
 124         return ret;
 125 }
 126
 127 static bool isram_check_addr(const void *addr, size_t n)
 128 {
 129         if ((addr >= (void *)L1_CODE_START) &&
 130             (addr < (void *)(L1_CODE_START + L1_CODE_LENGTH))) {
 131                 if ((addr + n) > (void *)(L1_CODE_START + L1_CODE_LENGTH)) {
 132                         show_stack(NULL, NULL);
 133                         pr_err("copy involving %p length (%zu) too long\n", addr, n);
 134                 }
 135                 return true;
 136         }
 137         return false;
 138 }
 139
 140 /*
 141  * The isram_memcpy() function copies n bytes from memory area src to memory area dest.
 142  * The isram_memcpy() function returns a pointer to dest.
 143  * Either dest or src can be in L1 instruction sram.
 144  */
 145 void *isram_memcpy(void *dest, const void *src, size_t n)
 146 {
 147         uint64_t data_in = 0, data_out = 0;
 148         size_t count;
 149         bool dest_in_l1, src_in_l1, need_data, put_data;
 150         unsigned char byte, *src_byte, *dest_byte;
 151
 152         src_byte = (unsigned char *)src;
 153         dest_byte = (unsigned char *)dest;
 154
 155         dest_in_l1 = isram_check_addr(dest, n);
 156         src_in_l1 = isram_check_addr(src, n);
 157
 158         need_data = true;
 159         put_data = true;
 160         for (count = 0; count < n; count++) {
 161                 if (src_in_l1) {
 162                         if (need_data) {
 163                                 data_in = isram_read(src + count);
 164                                 need_data = false;
 165                         }
 166
 167                         if (ADDR2LAST(src + count))
 168                                 need_data = true;
 169
 170                         byte = (unsigned char)((data_in >> ADDR2OFFSET(src + count)) & 0xff);
 171
 172                 } else {
 173                         /* src is in L2 or L3 - so just dereference*/
 174                         byte = src_byte[count];
 175                 }
 176
 177                 if (dest_in_l1) {
 178                         if (put_data) {
 179                                 data_out = isram_read(dest + count);
 180                                 put_data = false;
 181                         }
 182
 183                         data_out &= ~((uint64_t)0xff << ADDR2OFFSET(dest + count));
 184                         data_out |= ((uint64_t)byte << ADDR2OFFSET(dest + count));
 185
 186                         if (ADDR2LAST(dest + count)) {
 187                                 put_data = true;
 188                                 isram_write(dest + count, data_out);
 189                         }
 190                 } else {
 191                         /* dest in L2 or L3 - so just dereference */
 192                         dest_byte[count] = byte;
 193                 }
 194         }
 195
 196         /* make sure we dump the last byte if necessary */
 197         if (dest_in_l1 && !put_data)
 198                 isram_write(dest + count, data_out);
 199
 200         return dest;
 201 }
 202 EXPORT_SYMBOL(isram_memcpy);
 203
 204 #ifdef CONFIG_BFIN_ISRAM_SELF_TEST
 205
 206 #define TEST_LEN 0x100
 207
 208 static __init void hex_dump(unsigned char *buf, int len)
 209 {
 210         while (len--)
 211                 pr_cont("%02x", *buf++);
 212 }
 213
 214 static __init int isram_read_test(char *sdram, void *l1inst)
 215 {
 216         int i, ret = 0;
 217         uint64_t data1, data2;
 218
 219         pr_info("INFO: running isram_read tests\n");
 220
 221         /* setup some different data to play with */
 222         for (i = 0; i < TEST_LEN; ++i)
 223                 sdram[i] = i;
 224         dma_memcpy(l1inst, sdram, TEST_LEN);
 225
 226         /* make sure we can read the L1 inst */
 227         for (i = 0; i < TEST_LEN; i += sizeof(uint64_t)) {
 228                 data1 = isram_read(l1inst + i);
 229                 memcpy(&data2, sdram + i, sizeof(data2));
 230                 if (memcmp(&data1, &data2, sizeof(uint64_t))) {
 231                         pr_err("FAIL: isram_read(%p) returned %#llx but wanted %#llx\n",
 232                                 l1inst + i, data1, data2);
 233                         ++ret;
 234                 }
 235         }
 236
 237         return ret;
 238 }
 239
 240 static __init int isram_write_test(char *sdram, void *l1inst)
 241 {
 242         int i, ret = 0;
 243         uint64_t data1, data2;
 244
 245         pr_info("INFO: running isram_write tests\n");
 246
 247         /* setup some different data to play with */
 248         memset(sdram, 0, TEST_LEN * 2);
 249         dma_memcpy(l1inst, sdram, TEST_LEN);
 250         for (i = 0; i < TEST_LEN; ++i)
 251                 sdram[i] = i;
 252
 253         /* make sure we can write the L1 inst */
 254         for (i = 0; i < TEST_LEN; i += sizeof(uint64_t)) {
 255                 memcpy(&data1, sdram + i, sizeof(data1));
 256                 isram_write(l1inst + i, data1);
 257                 data2 = isram_read(l1inst + i);
 258                 if (memcmp(&data1, &data2, sizeof(uint64_t))) {
 259                         pr_err("FAIL: isram_write(%p, %#llx) != %#llx\n",
 260                                 l1inst + i, data1, data2);
 261                         ++ret;
 262                 }
 263         }
 264
 265         dma_memcpy(sdram + TEST_LEN, l1inst, TEST_LEN);
 266         if (memcmp(sdram, sdram + TEST_LEN, TEST_LEN)) {
 267                 pr_err("FAIL: isram_write() did not work properly\n");
 268                 ++ret;
 269         }
 270
 271         return ret;
 272 }
 273
 274 static __init int
 275 _isram_memcpy_test(char pattern, void *sdram, void *l1inst, const char *smemcpy,
 276                    void *(*fmemcpy)(void *, const void *, size_t))
 277 {
 278         memset(sdram, pattern, TEST_LEN);
 279         fmemcpy(l1inst, sdram, TEST_LEN);
 280         fmemcpy(sdram + TEST_LEN, l1inst, TEST_LEN);
 281         if (memcmp(sdram, sdram + TEST_LEN, TEST_LEN)) {
 282                 pr_err("FAIL: %s(%p <=> %p, %#x) failed (data is %#x)\n",
 283                         smemcpy, l1inst, sdram, TEST_LEN, pattern);
 284                 return 1;
 285         }
 286         return 0;
 287 }
 288 #define _isram_memcpy_test(a, b, c, d) _isram_memcpy_test(a, b, c, #d, d)
 289
 290 static __init int isram_memcpy_test(char *sdram, void *l1inst)
 291 {
 292         int i, j, thisret, ret = 0;
 293
 294         /* check broad isram_memcpy() */
 295         pr_info("INFO: running broad isram_memcpy tests\n");
 296         for (i = 0xf; i >= 0; --i)
 297                 ret += _isram_memcpy_test(i, sdram, l1inst, isram_memcpy);
 298
 299         /* check read of small, unaligned, and hardware 64bit limits */
 300         pr_info("INFO: running isram_memcpy (read) tests\n");
 301
 302         for (i = 0; i < TEST_LEN; ++i)
 303                 sdram[i] = i;
 304         dma_memcpy(l1inst, sdram, TEST_LEN);
 305
 306         thisret = 0;
 307         for (i = 0; i < TEST_LEN - 32; ++i) {
 308                 unsigned char cmp[32];
 309                 for (j = 1; j <= 32; ++j) {
 310                         memset(cmp, 0, sizeof(cmp));
 311                         isram_memcpy(cmp, l1inst + i, j);
 312                         if (memcmp(cmp, sdram + i, j)) {
 313                                 pr_err("FAIL: %p:", l1inst + 1);
 314                                 hex_dump(cmp, j);
 315                                 pr_cont(" SDRAM:");
 316                                 hex_dump(sdram + i, j);
 317                                 pr_cont("\n");
 318                                 if (++thisret > 20) {
 319                                         pr_err("FAIL: skipping remaining series\n");
 320                                         i = TEST_LEN;
 321                                         break;
 322                                 }
 323                         }
 324                 }
 325         }
 326         ret += thisret;
 327
 328         /* check write of small, unaligned, and hardware 64bit limits */
 329         pr_info("INFO: running isram_memcpy (write) tests\n");
 330
 331         memset(sdram + TEST_LEN, 0, TEST_LEN);
 332         dma_memcpy(l1inst, sdram + TEST_LEN, TEST_LEN);
 333
 334         thisret = 0;
 335         for (i = 0; i < TEST_LEN - 32; ++i) {
 336                 unsigned char cmp[32];
 337                 for (j = 1; j <= 32; ++j) {
 338                         isram_memcpy(l1inst + i, sdram + i, j);
 339                         dma_memcpy(cmp, l1inst + i, j);
 340                         if (memcmp(cmp, sdram + i, j)) {
 341                                 pr_err("FAIL: %p:", l1inst + i);
 342                                 hex_dump(cmp, j);
 343                                 pr_cont(" SDRAM:");
 344                                 hex_dump(sdram + i, j);
 345                                 pr_cont("\n");
 346                                 if (++thisret > 20) {
 347                                         pr_err("FAIL: skipping remaining series\n");
 348                                         i = TEST_LEN;
 349                                         break;
 350                                 }
 351                         }
 352                 }
 353         }
 354         ret += thisret;
 355
 356         return ret;
 357 }
 358
 359 static __init int isram_test_init(void)
 360 {
 361         int ret;
 362         char *sdram;
 363         void *l1inst;
 364
 365         sdram = kmalloc(TEST_LEN * 2, GFP_KERNEL);
 366         if (!sdram) {
 367                 pr_warning("SKIP: could not allocate sdram\n");
 368                 return 0;
 369         }
 370
 371         l1inst = l1_inst_sram_alloc(TEST_LEN);
 372         if (!l1inst) {
 373                 kfree(sdram);
 374                 pr_warning("SKIP: could not allocate L1 inst\n");
 375                 return 0;
 376         }
 377
 378         /* sanity check initial L1 inst state */
 379         ret = 1;
 380         pr_info("INFO: running initial dma_memcpy checks\n");
 381         if (_isram_memcpy_test(0xa, sdram, l1inst, dma_memcpy))
 382                 goto abort;
 383         if (_isram_memcpy_test(0x5, sdram, l1inst, dma_memcpy))
 384                 goto abort;
 385
 386         ret = 0;
 387         ret += isram_read_test(sdram, l1inst);
 388         ret += isram_write_test(sdram, l1inst);
 389         ret += isram_memcpy_test(sdram, l1inst);
 390
 391  abort:
 392         sram_free(l1inst);
 393         kfree(sdram);
 394
 395         if (ret)
 396                 return -EIO;
 397
 398         pr_info("PASS: all tests worked !\n");
 399         return 0;
 400 }
 401 late_initcall(isram_test_init);
 402
 403 static __exit void isram_test_exit(void)
 404 {
 405         /* stub to allow unloading */
 406 }
 407 module_exit(isram_test_exit);
 408
 409 #endif