arch/powerpc/sysdev/bestcomm/bestcomm.c

   1 /*
   2  * Driver for MPC52xx processor BestComm peripheral controller
   3  *
   4  *
   5  * Copyright (C) 2006-2007 Sylvain Munaut <tnt@246tNt.com>
   6  * Copyright (C) 2005      Varma Electronics Oy,
   7  *                         ( by Andrey Volkov <avolkov@varma-el.com> )
   8  * Copyright (C) 2003-2004 MontaVista, Software, Inc.
   9  *                         ( by Dale Farnsworth <dfarnsworth@mvista.com> )
  10  *
  11  * This file is licensed under the terms of the GNU General Public License
  12  * version 2. This program is licensed "as is" without any warranty of any
  13  * kind, whether express or implied.
  14  */
  15
  16 #include <linux/module.h>
  17 #include <linux/kernel.h>
  18 #include <linux/slab.h>
  19 #include <linux/of.h>
  20 #include <linux/of_device.h>
  21 #include <linux/of_platform.h>
  22 #include <asm/io.h>
  23 #include <asm/irq.h>
  24 #include <asm/mpc52xx.h>
  25
  26 #include "sram.h"
  27 #include "bestcomm_priv.h"
  28 #include "bestcomm.h"
  29
  30 #define DRIVER_NAME "bestcomm-core"
  31
  32 /* MPC5200 device tree match tables */
  33 static struct of_device_id mpc52xx_sram_ids[] __devinitdata = {
  34         { .compatible = "fsl,mpc5200-sram", },
  35         { .compatible = "mpc5200-sram", },
  36         {}
  37 };
  38
  39
  40 struct bcom_engine *bcom_eng = NULL;
  41 EXPORT_SYMBOL_GPL(bcom_eng);    /* needed for inline functions */
  42
  43 /* ======================================================================== */
  44 /* Public and private API                                                   */
  45 /* ======================================================================== */
  46
  47 /* Private API */
  48
  49 struct bcom_task *
  50 bcom_task_alloc(int bd_count, int bd_size, int priv_size)
  51 {
  52         int i, tasknum = -1;
  53         struct bcom_task *tsk;
  54
  55         /* Don't try to do anything if bestcomm init failed */
  56         if (!bcom_eng)
  57                 return NULL;
  58
  59         /* Get and reserve a task num */
  60         spin_lock(&bcom_eng->lock);
  61
  62         for (i=0; i<BCOM_MAX_TASKS; i++)
  63                 if (!bcom_eng->tdt[i].stop) {   /* we use stop as a marker */
  64                         bcom_eng->tdt[i].stop = 0xfffffffful; /* dummy addr */
  65                         tasknum = i;
  66                         break;
  67                 }
  68
  69         spin_unlock(&bcom_eng->lock);
  70
  71         if (tasknum < 0)
  72                 return NULL;
  73
  74         /* Allocate our structure */
  75         tsk = kzalloc(sizeof(struct bcom_task) + priv_size, GFP_KERNEL);
  76         if (!tsk)
  77                 goto error;
  78
  79         tsk->tasknum = tasknum;
  80         if (priv_size)
  81                 tsk->priv = (void*)tsk + sizeof(struct bcom_task);
  82
  83         /* Get IRQ of that task */
  84         tsk->irq = irq_of_parse_and_map(bcom_eng->ofnode, tsk->tasknum);
  85         if (tsk->irq == NO_IRQ)
  86                 goto error;
  87
  88         /* Init the BDs, if needed */
  89         if (bd_count) {
  90                 tsk->cookie = kmalloc(sizeof(void*) * bd_count, GFP_KERNEL);
  91                 if (!tsk->cookie)
  92                         goto error;
  93
  94                 tsk->bd = bcom_sram_alloc(bd_count * bd_size, 4, &tsk->bd_pa);
  95                 if (!tsk->bd)
  96                         goto error;
  97                 memset(tsk->bd, 0x00, bd_count * bd_size);
  98
  99                 tsk->num_bd = bd_count;
 100                 tsk->bd_size = bd_size;
 101         }
 102
 103         return tsk;
 104
 105 error:
 106         if (tsk) {
 107                 if (tsk->irq != NO_IRQ)
 108                         irq_dispose_mapping(tsk->irq);
 109                 bcom_sram_free(tsk->bd);
 110                 kfree(tsk->cookie);
 111                 kfree(tsk);
 112         }
 113
 114         bcom_eng->tdt[tasknum].stop = 0;
 115
 116         return NULL;
 117 }
 118 EXPORT_SYMBOL_GPL(bcom_task_alloc);
 119
 120 void
 121 bcom_task_free(struct bcom_task *tsk)
 122 {
 123         /* Stop the task */
 124         bcom_disable_task(tsk->tasknum);
 125
 126         /* Clear TDT */
 127         bcom_eng->tdt[tsk->tasknum].start = 0;
 128         bcom_eng->tdt[tsk->tasknum].stop  = 0;
 129
 130         /* Free everything */
 131         irq_dispose_mapping(tsk->irq);
 132         bcom_sram_free(tsk->bd);
 133         kfree(tsk->cookie);
 134         kfree(tsk);
 135 }
 136 EXPORT_SYMBOL_GPL(bcom_task_free);
 137
 138 int
 139 bcom_load_image(int task, u32 *task_image)
 140 {
 141         struct bcom_task_header *hdr = (struct bcom_task_header *)task_image;
 142         struct bcom_tdt *tdt;
 143         u32 *desc, *var, *inc;
 144         u32 *desc_src, *var_src, *inc_src;
 145
 146         /* Safety checks */
 147         if (hdr->magic != BCOM_TASK_MAGIC) {
 148                 printk(KERN_ERR DRIVER_NAME
 149                         ": Trying to load invalid microcode\n");
 150                 return -EINVAL;
 151         }
 152
 153         if ((task < 0) || (task >= BCOM_MAX_TASKS)) {
 154                 printk(KERN_ERR DRIVER_NAME
 155                         ": Trying to load invalid task %d\n", task);
 156                 return -EINVAL;
 157         }
 158
 159         /* Initial load or reload */
 160         tdt = &bcom_eng->tdt[task];
 161
 162         if (tdt->start) {
 163                 desc = bcom_task_desc(task);
 164                 if (hdr->desc_size != bcom_task_num_descs(task)) {
 165                         printk(KERN_ERR DRIVER_NAME
 166                                 ": Trying to reload wrong task image "
 167                                 "(%d size %d/%d)!\n",
 168                                 task,
 169                                 hdr->desc_size,
 170                                 bcom_task_num_descs(task));
 171                         return -EINVAL;
 172                 }
 173         } else {
 174                 phys_addr_t start_pa;
 175
 176                 desc = bcom_sram_alloc(hdr->desc_size * sizeof(u32), 4, &start_pa);
 177                 if (!desc)
 178                         return -ENOMEM;
 179
 180                 tdt->start = start_pa;
 181                 tdt->stop = start_pa + ((hdr->desc_size-1) * sizeof(u32));
 182         }
 183
 184         var = bcom_task_var(task);
 185         inc = bcom_task_inc(task);
 186
 187         /* Clear & copy */
 188         memset(var, 0x00, BCOM_VAR_SIZE);
 189         memset(inc, 0x00, BCOM_INC_SIZE);
 190
 191         desc_src = (u32 *)(hdr + 1);
 192         var_src = desc_src + hdr->desc_size;
 193         inc_src = var_src + hdr->var_size;
 194
 195         memcpy(desc, desc_src, hdr->desc_size * sizeof(u32));
 196         memcpy(var + hdr->first_var, var_src, hdr->var_size * sizeof(u32));
 197         memcpy(inc, inc_src, hdr->inc_size * sizeof(u32));
 198
 199         return 0;
 200 }
 201 EXPORT_SYMBOL_GPL(bcom_load_image);
 202
 203 void
 204 bcom_set_initiator(int task, int initiator)
 205 {
 206         int i;
 207         int num_descs;
 208         u32 *desc;
 209         int next_drd_has_initiator;
 210
 211         bcom_set_tcr_initiator(task, initiator);
 212
 213         /* Just setting tcr is apparently not enough due to some problem */
 214         /* with it. So we just go thru all the microcode and replace in  */
 215         /* the DRD directly */
 216
 217         desc = bcom_task_desc(task);
 218         next_drd_has_initiator = 1;
 219         num_descs = bcom_task_num_descs(task);
 220
 221         for (i=0; i<num_descs; i++, desc++) {
 222                 if (!bcom_desc_is_drd(*desc))
 223                         continue;
 224                 if (next_drd_has_initiator)
 225                         if (bcom_desc_initiator(*desc) != BCOM_INITIATOR_ALWAYS)
 226                                 bcom_set_desc_initiator(desc, initiator);
 227                 next_drd_has_initiator = !bcom_drd_is_extended(*desc);
 228         }
 229 }
 230 EXPORT_SYMBOL_GPL(bcom_set_initiator);
 231
 232
 233 /* Public API */
 234
 235 void
 236 bcom_enable(struct bcom_task *tsk)
 237 {
 238         bcom_enable_task(tsk->tasknum);
 239 }
 240 EXPORT_SYMBOL_GPL(bcom_enable);
 241
 242 void
 243 bcom_disable(struct bcom_task *tsk)
 244 {
 245         bcom_disable_task(tsk->tasknum);
 246 }
 247 EXPORT_SYMBOL_GPL(bcom_disable);
 248
 249
 250 /* ======================================================================== */
 251 /* Engine init/cleanup                                                      */
 252 /* ======================================================================== */
 253
 254 /* Function Descriptor table */
 255 /* this will need to be updated if Freescale changes their task code FDT */
 256 static u32 fdt_ops[] = {
 257         0xa0045670,     /* FDT[48] - load_acc()   */
 258         0x80045670,     /* FDT[49] - unload_acc() */
 259         0x21800000,     /* FDT[50] - and()        */
 260         0x21e00000,     /* FDT[51] - or()         */
 261         0x21500000,     /* FDT[52] - xor()        */
 262         0x21400000,     /* FDT[53] - andn()       */
 263         0x21500000,     /* FDT[54] - not()        */
 264         0x20400000,     /* FDT[55] - add()        */
 265         0x20500000,     /* FDT[56] - sub()        */
 266         0x20800000,     /* FDT[57] - lsh()        */
 267         0x20a00000,     /* FDT[58] - rsh()        */
 268         0xc0170000,     /* FDT[59] - crc8()       */
 269         0xc0145670,     /* FDT[60] - crc16()      */
 270         0xc0345670,     /* FDT[61] - crc32()      */
 271         0xa0076540,     /* FDT[62] - endian32()   */
 272         0xa0000760,     /* FDT[63] - endian16()   */
 273 };
 274
 275
 276 static int __devinit
 277 bcom_engine_init(void)
 278 {
 279         int task;
 280         phys_addr_t tdt_pa, ctx_pa, var_pa, fdt_pa;
 281         unsigned int tdt_size, ctx_size, var_size, fdt_size;
 282         u16 regval;
 283
 284         /* Allocate & clear SRAM zones for FDT, TDTs, contexts and vars/incs */
 285         tdt_size = BCOM_MAX_TASKS * sizeof(struct bcom_tdt);
 286         ctx_size = BCOM_MAX_TASKS * BCOM_CTX_SIZE;
 287         var_size = BCOM_MAX_TASKS * (BCOM_VAR_SIZE + BCOM_INC_SIZE);
 288         fdt_size = BCOM_FDT_SIZE;
 289
 290         bcom_eng->tdt = bcom_sram_alloc(tdt_size, sizeof(u32), &tdt_pa);
 291         bcom_eng->ctx = bcom_sram_alloc(ctx_size, BCOM_CTX_ALIGN, &ctx_pa);
 292         bcom_eng->var = bcom_sram_alloc(var_size, BCOM_VAR_ALIGN, &var_pa);
 293         bcom_eng->fdt = bcom_sram_alloc(fdt_size, BCOM_FDT_ALIGN, &fdt_pa);
 294
 295         if (!bcom_eng->tdt || !bcom_eng->ctx || !bcom_eng->var || !bcom_eng->fdt) {
 296                 printk(KERN_ERR "DMA: SRAM alloc failed in engine init !\n");
 297
 298                 bcom_sram_free(bcom_eng->tdt);
 299                 bcom_sram_free(bcom_eng->ctx);
 300                 bcom_sram_free(bcom_eng->var);
 301                 bcom_sram_free(bcom_eng->fdt);
 302
 303                 return -ENOMEM;
 304         }
 305
 306         memset(bcom_eng->tdt, 0x00, tdt_size);
 307         memset(bcom_eng->ctx, 0x00, ctx_size);
 308         memset(bcom_eng->var, 0x00, var_size);
 309         memset(bcom_eng->fdt, 0x00, fdt_size);
 310
 311         /* Copy the FDT for the EU#3 */
 312         memcpy(&bcom_eng->fdt[48], fdt_ops, sizeof(fdt_ops));
 313
 314         /* Initialize Task base structure */
 315         for (task=0; task<BCOM_MAX_TASKS; task++)
 316         {
 317                 out_be16(&bcom_eng->regs->tcr[task], 0);
 318                 out_8(&bcom_eng->regs->ipr[task], 0);
 319
 320                 bcom_eng->tdt[task].context     = ctx_pa;
 321                 bcom_eng->tdt[task].var = var_pa;
 322                 bcom_eng->tdt[task].fdt = fdt_pa;
 323
 324                 var_pa += BCOM_VAR_SIZE + BCOM_INC_SIZE;
 325                 ctx_pa += BCOM_CTX_SIZE;
 326         }
 327
 328         out_be32(&bcom_eng->regs->taskBar, tdt_pa);
 329
 330         /* Init 'always' initiator */
 331         out_8(&bcom_eng->regs->ipr[BCOM_INITIATOR_ALWAYS], BCOM_IPR_ALWAYS);
 332
 333         /* Disable COMM Bus Prefetch on the original 5200; it's broken */
 334         if ((mfspr(SPRN_SVR) & MPC5200_SVR_MASK) == MPC5200_SVR) {
 335                 regval = in_be16(&bcom_eng->regs->PtdCntrl);
 336                 out_be16(&bcom_eng->regs->PtdCntrl,  regval | 1);
 337         }
 338
 339         /* Init lock */
 340         spin_lock_init(&bcom_eng->lock);
 341
 342         return 0;
 343 }
 344
 345 static void
 346 bcom_engine_cleanup(void)
 347 {
 348         int task;
 349
 350         /* Stop all tasks */
 351         for (task=0; task<BCOM_MAX_TASKS; task++)
 352         {
 353                 out_be16(&bcom_eng->regs->tcr[task], 0);
 354                 out_8(&bcom_eng->regs->ipr[task], 0);
 355         }
 356
 357         out_be32(&bcom_eng->regs->taskBar, 0ul);
 358
 359         /* Release the SRAM zones */
 360         bcom_sram_free(bcom_eng->tdt);
 361         bcom_sram_free(bcom_eng->ctx);
 362         bcom_sram_free(bcom_eng->var);
 363         bcom_sram_free(bcom_eng->fdt);
 364 }
 365
 366
 367 /* ======================================================================== */
 368 /* OF platform driver                                                       */
 369 /* ======================================================================== */
 370
 371 static int __devinit
 372 mpc52xx_bcom_probe(struct of_device *op, const struct of_device_id *match)
 373 {
 374         struct device_node *ofn_sram;
 375         struct resource res_bcom;
 376
 377         int rv;
 378
 379         /* Inform user we're ok so far */
 380         printk(KERN_INFO "DMA: MPC52xx BestComm driver\n");
 381
 382         /* Get the bestcomm node */
 383         of_node_get(op->node);
 384
 385         /* Prepare SRAM */
 386         ofn_sram = of_find_matching_node(NULL, mpc52xx_sram_ids);
 387         if (!ofn_sram) {
 388                 printk(KERN_ERR DRIVER_NAME ": "
 389                         "No SRAM found in device tree\n");
 390                 rv = -ENODEV;
 391                 goto error_ofput;
 392         }
 393         rv = bcom_sram_init(ofn_sram, DRIVER_NAME);
 394         of_node_put(ofn_sram);
 395
 396         if (rv) {
 397                 printk(KERN_ERR DRIVER_NAME ": "
 398                         "Error in SRAM init\n");
 399                 goto error_ofput;
 400         }
 401
 402         /* Get a clean struct */
 403         bcom_eng = kzalloc(sizeof(struct bcom_engine), GFP_KERNEL);
 404         if (!bcom_eng) {
 405                 printk(KERN_ERR DRIVER_NAME ": "
 406                         "Can't allocate state structure\n");
 407                 rv = -ENOMEM;
 408                 goto error_sramclean;
 409         }
 410
 411         /* Save the node */
 412         bcom_eng->ofnode = op->node;
 413
 414         /* Get, reserve & map io */
 415         if (of_address_to_resource(op->node, 0, &res_bcom)) {
 416                 printk(KERN_ERR DRIVER_NAME ": "
 417                         "Can't get resource\n");
 418                 rv = -EINVAL;
 419                 goto error_sramclean;
 420         }
 421
 422         if (!request_mem_region(res_bcom.start, sizeof(struct mpc52xx_sdma),
 423                                 DRIVER_NAME)) {
 424                 printk(KERN_ERR DRIVER_NAME ": "
 425                         "Can't request registers region\n");
 426                 rv = -EBUSY;
 427                 goto error_sramclean;
 428         }
 429
 430         bcom_eng->regs_base = res_bcom.start;
 431         bcom_eng->regs = ioremap(res_bcom.start, sizeof(struct mpc52xx_sdma));
 432         if (!bcom_eng->regs) {
 433                 printk(KERN_ERR DRIVER_NAME ": "
 434                         "Can't map registers\n");
 435                 rv = -ENOMEM;
 436                 goto error_release;
 437         }
 438
 439         /* Now, do the real init */
 440         rv = bcom_engine_init();
 441         if (rv)
 442                 goto error_unmap;
 443
 444         /* Done ! */
 445         printk(KERN_INFO "DMA: MPC52xx BestComm engine @%08lx ok !\n",
 446                 (long)bcom_eng->regs_base);
 447
 448         return 0;
 449
 450         /* Error path */
 451 error_unmap:
 452         iounmap(bcom_eng->regs);
 453 error_release:
 454         release_mem_region(res_bcom.start, sizeof(struct mpc52xx_sdma));
 455 error_sramclean:
 456         kfree(bcom_eng);
 457         bcom_sram_cleanup();
 458 error_ofput:
 459         of_node_put(op->node);
 460
 461         printk(KERN_ERR "DMA: MPC52xx BestComm init failed !\n");
 462
 463         return rv;
 464 }
 465
 466
 467 static int
 468 mpc52xx_bcom_remove(struct of_device *op)
 469 {
 470         /* Clean up the engine */
 471         bcom_engine_cleanup();
 472
 473         /* Cleanup SRAM */
 474         bcom_sram_cleanup();
 475
 476         /* Release regs */
 477         iounmap(bcom_eng->regs);
 478         release_mem_region(bcom_eng->regs_base, sizeof(struct mpc52xx_sdma));
 479
 480         /* Release the node */
 481         of_node_put(bcom_eng->ofnode);
 482
 483         /* Release memory */
 484         kfree(bcom_eng);
 485         bcom_eng = NULL;
 486
 487         return 0;
 488 }
 489
 490 static struct of_device_id mpc52xx_bcom_of_match[] = {
 491         { .compatible = "fsl,mpc5200-bestcomm", },
 492         { .compatible = "mpc5200-bestcomm", },
 493         {},
 494 };
 495
 496 MODULE_DEVICE_TABLE(of, mpc52xx_bcom_of_match);
 497
 498
 499 static struct of_platform_driver mpc52xx_bcom_of_platform_driver = {
 500         .owner          = THIS_MODULE,
 501         .name           = DRIVER_NAME,
 502         .match_table    = mpc52xx_bcom_of_match,
 503         .probe          = mpc52xx_bcom_probe,
 504         .remove         = mpc52xx_bcom_remove,
 505         .driver         = {
 506                 .name   = DRIVER_NAME,
 507                 .owner  = THIS_MODULE,
 508         },
 509 };
 510
 511
 512 /* ======================================================================== */
 513 /* Module                                                                   */
 514 /* ======================================================================== */
 515
 516 static int __init
 517 mpc52xx_bcom_init(void)
 518 {
 519         return of_register_platform_driver(&mpc52xx_bcom_of_platform_driver);
 520 }
 521
 522 static void __exit
 523 mpc52xx_bcom_exit(void)
 524 {
 525         of_unregister_platform_driver(&mpc52xx_bcom_of_platform_driver);
 526 }
 527
 528 /* If we're not a module, we must make sure everything is setup before  */
 529 /* anyone tries to use us ... that's why we use subsys_initcall instead */
 530 /* of module_init. */
 531 subsys_initcall(mpc52xx_bcom_init);
 532 module_exit(mpc52xx_bcom_exit);
 533
 534 MODULE_DESCRIPTION("Freescale MPC52xx BestComm DMA");
 535 MODULE_AUTHOR("Sylvain Munaut <tnt@246tNt.com>");
 536 MODULE_AUTHOR("Andrey Volkov <avolkov@varma-el.com>");
 537 MODULE_AUTHOR("Dale Farnsworth <dfarnsworth@mvista.com>");
 538 MODULE_LICENSE("GPL v2");
 539