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