1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * General Purpose functions for the global management of the 4 * Communication Processor Module. 5 * Copyright (c) 1997 Dan error_act (dmalek@jlc.net) 6 * 7 * In addition to the individual control of the communication 8 * channels, there are a few functions that globally affect the 9 * communication processor. 10 * 11 * Buffer descriptors must be allocated from the dual ported memory 12 * space. The allocator for that is here. When the communication 13 * process is reset, we reclaim the memory available. There is 14 * currently no deallocator for this memory. 15 * The amount of space available is platform dependent. On the 16 * MBX, the EPPC software loads additional microcode into the 17 * communication processor, and uses some of the DP ram for this 18 * purpose. Current, the first 512 bytes and the last 256 bytes of 19 * memory are used. Right now I am conservative and only use the 20 * memory that can never be used for microcode. If there are 21 * applications that require more DP ram, we can expand the boundaries 22 * but then we have to be careful of any downloaded microcode. 23 */ 24 #include <linux/errno.h> 25 #include <linux/sched.h> 26 #include <linux/kernel.h> 27 #include <linux/dma-mapping.h> 28 #include <linux/param.h> 29 #include <linux/string.h> 30 #include <linux/mm.h> 31 #include <linux/interrupt.h> 32 #include <linux/irq.h> 33 #include <linux/module.h> 34 #include <linux/spinlock.h> 35 #include <linux/slab.h> 36 #include <asm/page.h> 37 #include <asm/pgtable.h> 38 #include <asm/8xx_immap.h> 39 #include <asm/cpm1.h> 40 #include <asm/io.h> 41 #include <asm/rheap.h> 42 #include <asm/prom.h> 43 #include <asm/cpm.h> 44 45 #include <asm/fs_pd.h> 46 47 #ifdef CONFIG_8xx_GPIO 48 #include <linux/of_gpio.h> 49 #endif 50 51 #define CPM_MAP_SIZE (0x4000) 52 53 cpm8xx_t __iomem *cpmp; /* Pointer to comm processor space */ 54 immap_t __iomem *mpc8xx_immr = (void __iomem *)VIRT_IMMR_BASE; 55 static cpic8xx_t __iomem *cpic_reg; 56 57 static struct irq_domain *cpm_pic_host; 58 59 static void cpm_mask_irq(struct irq_data *d) 60 { 61 unsigned int cpm_vec = (unsigned int)irqd_to_hwirq(d); 62 63 clrbits32(&cpic_reg->cpic_cimr, (1 << cpm_vec)); 64 } 65 66 static void cpm_unmask_irq(struct irq_data *d) 67 { 68 unsigned int cpm_vec = (unsigned int)irqd_to_hwirq(d); 69 70 setbits32(&cpic_reg->cpic_cimr, (1 << cpm_vec)); 71 } 72 73 static void cpm_end_irq(struct irq_data *d) 74 { 75 unsigned int cpm_vec = (unsigned int)irqd_to_hwirq(d); 76 77 out_be32(&cpic_reg->cpic_cisr, (1 << cpm_vec)); 78 } 79 80 static struct irq_chip cpm_pic = { 81 .name = "CPM PIC", 82 .irq_mask = cpm_mask_irq, 83 .irq_unmask = cpm_unmask_irq, 84 .irq_eoi = cpm_end_irq, 85 }; 86 87 int cpm_get_irq(void) 88 { 89 int cpm_vec; 90 91 /* 92 * Get the vector by setting the ACK bit and then reading 93 * the register. 94 */ 95 out_be16(&cpic_reg->cpic_civr, 1); 96 cpm_vec = in_be16(&cpic_reg->cpic_civr); 97 cpm_vec >>= 11; 98 99 return irq_linear_revmap(cpm_pic_host, cpm_vec); 100 } 101 102 static int cpm_pic_host_map(struct irq_domain *h, unsigned int virq, 103 irq_hw_number_t hw) 104 { 105 pr_debug("cpm_pic_host_map(%d, 0x%lx)\n", virq, hw); 106 107 irq_set_status_flags(virq, IRQ_LEVEL); 108 irq_set_chip_and_handler(virq, &cpm_pic, handle_fasteoi_irq); 109 return 0; 110 } 111 112 /* 113 * The CPM can generate the error interrupt when there is a race condition 114 * between generating and masking interrupts. All we have to do is ACK it 115 * and return. This is a no-op function so we don't need any special 116 * tests in the interrupt handler. 117 */ 118 static irqreturn_t cpm_error_interrupt(int irq, void *dev) 119 { 120 return IRQ_HANDLED; 121 } 122 123 static const struct irq_domain_ops cpm_pic_host_ops = { 124 .map = cpm_pic_host_map, 125 }; 126 127 unsigned int __init cpm_pic_init(void) 128 { 129 struct device_node *np = NULL; 130 struct resource res; 131 unsigned int sirq = 0, hwirq, eirq; 132 int ret; 133 134 pr_debug("cpm_pic_init\n"); 135 136 np = of_find_compatible_node(NULL, NULL, "fsl,cpm1-pic"); 137 if (np == NULL) 138 np = of_find_compatible_node(NULL, "cpm-pic", "CPM"); 139 if (np == NULL) { 140 printk(KERN_ERR "CPM PIC init: can not find cpm-pic node\n"); 141 return sirq; 142 } 143 144 ret = of_address_to_resource(np, 0, &res); 145 if (ret) 146 goto end; 147 148 cpic_reg = ioremap(res.start, resource_size(&res)); 149 if (cpic_reg == NULL) 150 goto end; 151 152 sirq = irq_of_parse_and_map(np, 0); 153 if (!sirq) 154 goto end; 155 156 /* Initialize the CPM interrupt controller. */ 157 hwirq = (unsigned int)virq_to_hw(sirq); 158 out_be32(&cpic_reg->cpic_cicr, 159 (CICR_SCD_SCC4 | CICR_SCC_SCC3 | CICR_SCB_SCC2 | CICR_SCA_SCC1) | 160 ((hwirq/2) << 13) | CICR_HP_MASK); 161 162 out_be32(&cpic_reg->cpic_cimr, 0); 163 164 cpm_pic_host = irq_domain_add_linear(np, 64, &cpm_pic_host_ops, NULL); 165 if (cpm_pic_host == NULL) { 166 printk(KERN_ERR "CPM2 PIC: failed to allocate irq host!\n"); 167 sirq = 0; 168 goto end; 169 } 170 171 /* Install our own error handler. */ 172 np = of_find_compatible_node(NULL, NULL, "fsl,cpm1"); 173 if (np == NULL) 174 np = of_find_node_by_type(NULL, "cpm"); 175 if (np == NULL) { 176 printk(KERN_ERR "CPM PIC init: can not find cpm node\n"); 177 goto end; 178 } 179 180 eirq = irq_of_parse_and_map(np, 0); 181 if (!eirq) 182 goto end; 183 184 if (request_irq(eirq, cpm_error_interrupt, IRQF_NO_THREAD, "error", 185 NULL)) 186 printk(KERN_ERR "Could not allocate CPM error IRQ!"); 187 188 setbits32(&cpic_reg->cpic_cicr, CICR_IEN); 189 190 end: 191 of_node_put(np); 192 return sirq; 193 } 194 195 void __init cpm_reset(void) 196 { 197 sysconf8xx_t __iomem *siu_conf; 198 199 cpmp = &mpc8xx_immr->im_cpm; 200 201 #ifndef CONFIG_PPC_EARLY_DEBUG_CPM 202 /* Perform a reset. */ 203 out_be16(&cpmp->cp_cpcr, CPM_CR_RST | CPM_CR_FLG); 204 205 /* Wait for it. */ 206 while (in_be16(&cpmp->cp_cpcr) & CPM_CR_FLG); 207 #endif 208 209 #ifdef CONFIG_UCODE_PATCH 210 cpm_load_patch(cpmp); 211 #endif 212 213 /* 214 * Set SDMA Bus Request priority 5. 215 * On 860T, this also enables FEC priority 6. I am not sure 216 * this is what we really want for some applications, but the 217 * manual recommends it. 218 * Bit 25, FAM can also be set to use FEC aggressive mode (860T). 219 */ 220 siu_conf = immr_map(im_siu_conf); 221 if ((mfspr(SPRN_IMMR) & 0xffff) == 0x0900) /* MPC885 */ 222 out_be32(&siu_conf->sc_sdcr, 0x40); 223 else 224 out_be32(&siu_conf->sc_sdcr, 1); 225 immr_unmap(siu_conf); 226 } 227 228 static DEFINE_SPINLOCK(cmd_lock); 229 230 #define MAX_CR_CMD_LOOPS 10000 231 232 int cpm_command(u32 command, u8 opcode) 233 { 234 int i, ret; 235 unsigned long flags; 236 237 if (command & 0xffffff0f) 238 return -EINVAL; 239 240 spin_lock_irqsave(&cmd_lock, flags); 241 242 ret = 0; 243 out_be16(&cpmp->cp_cpcr, command | CPM_CR_FLG | (opcode << 8)); 244 for (i = 0; i < MAX_CR_CMD_LOOPS; i++) 245 if ((in_be16(&cpmp->cp_cpcr) & CPM_CR_FLG) == 0) 246 goto out; 247 248 printk(KERN_ERR "%s(): Not able to issue CPM command\n", __func__); 249 ret = -EIO; 250 out: 251 spin_unlock_irqrestore(&cmd_lock, flags); 252 return ret; 253 } 254 EXPORT_SYMBOL(cpm_command); 255 256 /* 257 * Set a baud rate generator. This needs lots of work. There are 258 * four BRGs, any of which can be wired to any channel. 259 * The internal baud rate clock is the system clock divided by 16. 260 * This assumes the baudrate is 16x oversampled by the uart. 261 */ 262 #define BRG_INT_CLK (get_brgfreq()) 263 #define BRG_UART_CLK (BRG_INT_CLK/16) 264 #define BRG_UART_CLK_DIV16 (BRG_UART_CLK/16) 265 266 void 267 cpm_setbrg(uint brg, uint rate) 268 { 269 u32 __iomem *bp; 270 271 /* This is good enough to get SMCs running..... */ 272 bp = &cpmp->cp_brgc1; 273 bp += brg; 274 /* 275 * The BRG has a 12-bit counter. For really slow baud rates (or 276 * really fast processors), we may have to further divide by 16. 277 */ 278 if (((BRG_UART_CLK / rate) - 1) < 4096) 279 out_be32(bp, (((BRG_UART_CLK / rate) - 1) << 1) | CPM_BRG_EN); 280 else 281 out_be32(bp, (((BRG_UART_CLK_DIV16 / rate) - 1) << 1) | 282 CPM_BRG_EN | CPM_BRG_DIV16); 283 } 284 285 struct cpm_ioport16 { 286 __be16 dir, par, odr_sor, dat, intr; 287 __be16 res[3]; 288 }; 289 290 struct cpm_ioport32b { 291 __be32 dir, par, odr, dat; 292 }; 293 294 struct cpm_ioport32e { 295 __be32 dir, par, sor, odr, dat; 296 }; 297 298 static void __init cpm1_set_pin32(int port, int pin, int flags) 299 { 300 struct cpm_ioport32e __iomem *iop; 301 pin = 1 << (31 - pin); 302 303 if (port == CPM_PORTB) 304 iop = (struct cpm_ioport32e __iomem *) 305 &mpc8xx_immr->im_cpm.cp_pbdir; 306 else 307 iop = (struct cpm_ioport32e __iomem *) 308 &mpc8xx_immr->im_cpm.cp_pedir; 309 310 if (flags & CPM_PIN_OUTPUT) 311 setbits32(&iop->dir, pin); 312 else 313 clrbits32(&iop->dir, pin); 314 315 if (!(flags & CPM_PIN_GPIO)) 316 setbits32(&iop->par, pin); 317 else 318 clrbits32(&iop->par, pin); 319 320 if (port == CPM_PORTB) { 321 if (flags & CPM_PIN_OPENDRAIN) 322 setbits16(&mpc8xx_immr->im_cpm.cp_pbodr, pin); 323 else 324 clrbits16(&mpc8xx_immr->im_cpm.cp_pbodr, pin); 325 } 326 327 if (port == CPM_PORTE) { 328 if (flags & CPM_PIN_SECONDARY) 329 setbits32(&iop->sor, pin); 330 else 331 clrbits32(&iop->sor, pin); 332 333 if (flags & CPM_PIN_OPENDRAIN) 334 setbits32(&mpc8xx_immr->im_cpm.cp_peodr, pin); 335 else 336 clrbits32(&mpc8xx_immr->im_cpm.cp_peodr, pin); 337 } 338 } 339 340 static void __init cpm1_set_pin16(int port, int pin, int flags) 341 { 342 struct cpm_ioport16 __iomem *iop = 343 (struct cpm_ioport16 __iomem *)&mpc8xx_immr->im_ioport; 344 345 pin = 1 << (15 - pin); 346 347 if (port != 0) 348 iop += port - 1; 349 350 if (flags & CPM_PIN_OUTPUT) 351 setbits16(&iop->dir, pin); 352 else 353 clrbits16(&iop->dir, pin); 354 355 if (!(flags & CPM_PIN_GPIO)) 356 setbits16(&iop->par, pin); 357 else 358 clrbits16(&iop->par, pin); 359 360 if (port == CPM_PORTA) { 361 if (flags & CPM_PIN_OPENDRAIN) 362 setbits16(&iop->odr_sor, pin); 363 else 364 clrbits16(&iop->odr_sor, pin); 365 } 366 if (port == CPM_PORTC) { 367 if (flags & CPM_PIN_SECONDARY) 368 setbits16(&iop->odr_sor, pin); 369 else 370 clrbits16(&iop->odr_sor, pin); 371 if (flags & CPM_PIN_FALLEDGE) 372 setbits16(&iop->intr, pin); 373 else 374 clrbits16(&iop->intr, pin); 375 } 376 } 377 378 void __init cpm1_set_pin(enum cpm_port port, int pin, int flags) 379 { 380 if (port == CPM_PORTB || port == CPM_PORTE) 381 cpm1_set_pin32(port, pin, flags); 382 else 383 cpm1_set_pin16(port, pin, flags); 384 } 385 386 int __init cpm1_clk_setup(enum cpm_clk_target target, int clock, int mode) 387 { 388 int shift; 389 int i, bits = 0; 390 u32 __iomem *reg; 391 u32 mask = 7; 392 393 u8 clk_map[][3] = { 394 {CPM_CLK_SCC1, CPM_BRG1, 0}, 395 {CPM_CLK_SCC1, CPM_BRG2, 1}, 396 {CPM_CLK_SCC1, CPM_BRG3, 2}, 397 {CPM_CLK_SCC1, CPM_BRG4, 3}, 398 {CPM_CLK_SCC1, CPM_CLK1, 4}, 399 {CPM_CLK_SCC1, CPM_CLK2, 5}, 400 {CPM_CLK_SCC1, CPM_CLK3, 6}, 401 {CPM_CLK_SCC1, CPM_CLK4, 7}, 402 403 {CPM_CLK_SCC2, CPM_BRG1, 0}, 404 {CPM_CLK_SCC2, CPM_BRG2, 1}, 405 {CPM_CLK_SCC2, CPM_BRG3, 2}, 406 {CPM_CLK_SCC2, CPM_BRG4, 3}, 407 {CPM_CLK_SCC2, CPM_CLK1, 4}, 408 {CPM_CLK_SCC2, CPM_CLK2, 5}, 409 {CPM_CLK_SCC2, CPM_CLK3, 6}, 410 {CPM_CLK_SCC2, CPM_CLK4, 7}, 411 412 {CPM_CLK_SCC3, CPM_BRG1, 0}, 413 {CPM_CLK_SCC3, CPM_BRG2, 1}, 414 {CPM_CLK_SCC3, CPM_BRG3, 2}, 415 {CPM_CLK_SCC3, CPM_BRG4, 3}, 416 {CPM_CLK_SCC3, CPM_CLK5, 4}, 417 {CPM_CLK_SCC3, CPM_CLK6, 5}, 418 {CPM_CLK_SCC3, CPM_CLK7, 6}, 419 {CPM_CLK_SCC3, CPM_CLK8, 7}, 420 421 {CPM_CLK_SCC4, CPM_BRG1, 0}, 422 {CPM_CLK_SCC4, CPM_BRG2, 1}, 423 {CPM_CLK_SCC4, CPM_BRG3, 2}, 424 {CPM_CLK_SCC4, CPM_BRG4, 3}, 425 {CPM_CLK_SCC4, CPM_CLK5, 4}, 426 {CPM_CLK_SCC4, CPM_CLK6, 5}, 427 {CPM_CLK_SCC4, CPM_CLK7, 6}, 428 {CPM_CLK_SCC4, CPM_CLK8, 7}, 429 430 {CPM_CLK_SMC1, CPM_BRG1, 0}, 431 {CPM_CLK_SMC1, CPM_BRG2, 1}, 432 {CPM_CLK_SMC1, CPM_BRG3, 2}, 433 {CPM_CLK_SMC1, CPM_BRG4, 3}, 434 {CPM_CLK_SMC1, CPM_CLK1, 4}, 435 {CPM_CLK_SMC1, CPM_CLK2, 5}, 436 {CPM_CLK_SMC1, CPM_CLK3, 6}, 437 {CPM_CLK_SMC1, CPM_CLK4, 7}, 438 439 {CPM_CLK_SMC2, CPM_BRG1, 0}, 440 {CPM_CLK_SMC2, CPM_BRG2, 1}, 441 {CPM_CLK_SMC2, CPM_BRG3, 2}, 442 {CPM_CLK_SMC2, CPM_BRG4, 3}, 443 {CPM_CLK_SMC2, CPM_CLK5, 4}, 444 {CPM_CLK_SMC2, CPM_CLK6, 5}, 445 {CPM_CLK_SMC2, CPM_CLK7, 6}, 446 {CPM_CLK_SMC2, CPM_CLK8, 7}, 447 }; 448 449 switch (target) { 450 case CPM_CLK_SCC1: 451 reg = &mpc8xx_immr->im_cpm.cp_sicr; 452 shift = 0; 453 break; 454 455 case CPM_CLK_SCC2: 456 reg = &mpc8xx_immr->im_cpm.cp_sicr; 457 shift = 8; 458 break; 459 460 case CPM_CLK_SCC3: 461 reg = &mpc8xx_immr->im_cpm.cp_sicr; 462 shift = 16; 463 break; 464 465 case CPM_CLK_SCC4: 466 reg = &mpc8xx_immr->im_cpm.cp_sicr; 467 shift = 24; 468 break; 469 470 case CPM_CLK_SMC1: 471 reg = &mpc8xx_immr->im_cpm.cp_simode; 472 shift = 12; 473 break; 474 475 case CPM_CLK_SMC2: 476 reg = &mpc8xx_immr->im_cpm.cp_simode; 477 shift = 28; 478 break; 479 480 default: 481 printk(KERN_ERR "cpm1_clock_setup: invalid clock target\n"); 482 return -EINVAL; 483 } 484 485 for (i = 0; i < ARRAY_SIZE(clk_map); i++) { 486 if (clk_map[i][0] == target && clk_map[i][1] == clock) { 487 bits = clk_map[i][2]; 488 break; 489 } 490 } 491 492 if (i == ARRAY_SIZE(clk_map)) { 493 printk(KERN_ERR "cpm1_clock_setup: invalid clock combination\n"); 494 return -EINVAL; 495 } 496 497 bits <<= shift; 498 mask <<= shift; 499 500 if (reg == &mpc8xx_immr->im_cpm.cp_sicr) { 501 if (mode == CPM_CLK_RTX) { 502 bits |= bits << 3; 503 mask |= mask << 3; 504 } else if (mode == CPM_CLK_RX) { 505 bits <<= 3; 506 mask <<= 3; 507 } 508 } 509 510 out_be32(reg, (in_be32(reg) & ~mask) | bits); 511 512 return 0; 513 } 514 515 /* 516 * GPIO LIB API implementation 517 */ 518 #ifdef CONFIG_8xx_GPIO 519 520 struct cpm1_gpio16_chip { 521 struct of_mm_gpio_chip mm_gc; 522 spinlock_t lock; 523 524 /* shadowed data register to clear/set bits safely */ 525 u16 cpdata; 526 527 /* IRQ associated with Pins when relevant */ 528 int irq[16]; 529 }; 530 531 static void cpm1_gpio16_save_regs(struct of_mm_gpio_chip *mm_gc) 532 { 533 struct cpm1_gpio16_chip *cpm1_gc = 534 container_of(mm_gc, struct cpm1_gpio16_chip, mm_gc); 535 struct cpm_ioport16 __iomem *iop = mm_gc->regs; 536 537 cpm1_gc->cpdata = in_be16(&iop->dat); 538 } 539 540 static int cpm1_gpio16_get(struct gpio_chip *gc, unsigned int gpio) 541 { 542 struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc); 543 struct cpm_ioport16 __iomem *iop = mm_gc->regs; 544 u16 pin_mask; 545 546 pin_mask = 1 << (15 - gpio); 547 548 return !!(in_be16(&iop->dat) & pin_mask); 549 } 550 551 static void __cpm1_gpio16_set(struct of_mm_gpio_chip *mm_gc, u16 pin_mask, 552 int value) 553 { 554 struct cpm1_gpio16_chip *cpm1_gc = gpiochip_get_data(&mm_gc->gc); 555 struct cpm_ioport16 __iomem *iop = mm_gc->regs; 556 557 if (value) 558 cpm1_gc->cpdata |= pin_mask; 559 else 560 cpm1_gc->cpdata &= ~pin_mask; 561 562 out_be16(&iop->dat, cpm1_gc->cpdata); 563 } 564 565 static void cpm1_gpio16_set(struct gpio_chip *gc, unsigned int gpio, int value) 566 { 567 struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc); 568 struct cpm1_gpio16_chip *cpm1_gc = gpiochip_get_data(&mm_gc->gc); 569 unsigned long flags; 570 u16 pin_mask = 1 << (15 - gpio); 571 572 spin_lock_irqsave(&cpm1_gc->lock, flags); 573 574 __cpm1_gpio16_set(mm_gc, pin_mask, value); 575 576 spin_unlock_irqrestore(&cpm1_gc->lock, flags); 577 } 578 579 static int cpm1_gpio16_to_irq(struct gpio_chip *gc, unsigned int gpio) 580 { 581 struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc); 582 struct cpm1_gpio16_chip *cpm1_gc = gpiochip_get_data(&mm_gc->gc); 583 584 return cpm1_gc->irq[gpio] ? : -ENXIO; 585 } 586 587 static int cpm1_gpio16_dir_out(struct gpio_chip *gc, unsigned int gpio, int val) 588 { 589 struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc); 590 struct cpm1_gpio16_chip *cpm1_gc = gpiochip_get_data(&mm_gc->gc); 591 struct cpm_ioport16 __iomem *iop = mm_gc->regs; 592 unsigned long flags; 593 u16 pin_mask = 1 << (15 - gpio); 594 595 spin_lock_irqsave(&cpm1_gc->lock, flags); 596 597 setbits16(&iop->dir, pin_mask); 598 __cpm1_gpio16_set(mm_gc, pin_mask, val); 599 600 spin_unlock_irqrestore(&cpm1_gc->lock, flags); 601 602 return 0; 603 } 604 605 static int cpm1_gpio16_dir_in(struct gpio_chip *gc, unsigned int gpio) 606 { 607 struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc); 608 struct cpm1_gpio16_chip *cpm1_gc = gpiochip_get_data(&mm_gc->gc); 609 struct cpm_ioport16 __iomem *iop = mm_gc->regs; 610 unsigned long flags; 611 u16 pin_mask = 1 << (15 - gpio); 612 613 spin_lock_irqsave(&cpm1_gc->lock, flags); 614 615 clrbits16(&iop->dir, pin_mask); 616 617 spin_unlock_irqrestore(&cpm1_gc->lock, flags); 618 619 return 0; 620 } 621 622 int cpm1_gpiochip_add16(struct device *dev) 623 { 624 struct device_node *np = dev->of_node; 625 struct cpm1_gpio16_chip *cpm1_gc; 626 struct of_mm_gpio_chip *mm_gc; 627 struct gpio_chip *gc; 628 u16 mask; 629 630 cpm1_gc = kzalloc(sizeof(*cpm1_gc), GFP_KERNEL); 631 if (!cpm1_gc) 632 return -ENOMEM; 633 634 spin_lock_init(&cpm1_gc->lock); 635 636 if (!of_property_read_u16(np, "fsl,cpm1-gpio-irq-mask", &mask)) { 637 int i, j; 638 639 for (i = 0, j = 0; i < 16; i++) 640 if (mask & (1 << (15 - i))) 641 cpm1_gc->irq[i] = irq_of_parse_and_map(np, j++); 642 } 643 644 mm_gc = &cpm1_gc->mm_gc; 645 gc = &mm_gc->gc; 646 647 mm_gc->save_regs = cpm1_gpio16_save_regs; 648 gc->ngpio = 16; 649 gc->direction_input = cpm1_gpio16_dir_in; 650 gc->direction_output = cpm1_gpio16_dir_out; 651 gc->get = cpm1_gpio16_get; 652 gc->set = cpm1_gpio16_set; 653 gc->to_irq = cpm1_gpio16_to_irq; 654 gc->parent = dev; 655 gc->owner = THIS_MODULE; 656 657 return of_mm_gpiochip_add_data(np, mm_gc, cpm1_gc); 658 } 659 660 struct cpm1_gpio32_chip { 661 struct of_mm_gpio_chip mm_gc; 662 spinlock_t lock; 663 664 /* shadowed data register to clear/set bits safely */ 665 u32 cpdata; 666 }; 667 668 static void cpm1_gpio32_save_regs(struct of_mm_gpio_chip *mm_gc) 669 { 670 struct cpm1_gpio32_chip *cpm1_gc = 671 container_of(mm_gc, struct cpm1_gpio32_chip, mm_gc); 672 struct cpm_ioport32b __iomem *iop = mm_gc->regs; 673 674 cpm1_gc->cpdata = in_be32(&iop->dat); 675 } 676 677 static int cpm1_gpio32_get(struct gpio_chip *gc, unsigned int gpio) 678 { 679 struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc); 680 struct cpm_ioport32b __iomem *iop = mm_gc->regs; 681 u32 pin_mask; 682 683 pin_mask = 1 << (31 - gpio); 684 685 return !!(in_be32(&iop->dat) & pin_mask); 686 } 687 688 static void __cpm1_gpio32_set(struct of_mm_gpio_chip *mm_gc, u32 pin_mask, 689 int value) 690 { 691 struct cpm1_gpio32_chip *cpm1_gc = gpiochip_get_data(&mm_gc->gc); 692 struct cpm_ioport32b __iomem *iop = mm_gc->regs; 693 694 if (value) 695 cpm1_gc->cpdata |= pin_mask; 696 else 697 cpm1_gc->cpdata &= ~pin_mask; 698 699 out_be32(&iop->dat, cpm1_gc->cpdata); 700 } 701 702 static void cpm1_gpio32_set(struct gpio_chip *gc, unsigned int gpio, int value) 703 { 704 struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc); 705 struct cpm1_gpio32_chip *cpm1_gc = gpiochip_get_data(&mm_gc->gc); 706 unsigned long flags; 707 u32 pin_mask = 1 << (31 - gpio); 708 709 spin_lock_irqsave(&cpm1_gc->lock, flags); 710 711 __cpm1_gpio32_set(mm_gc, pin_mask, value); 712 713 spin_unlock_irqrestore(&cpm1_gc->lock, flags); 714 } 715 716 static int cpm1_gpio32_dir_out(struct gpio_chip *gc, unsigned int gpio, int val) 717 { 718 struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc); 719 struct cpm1_gpio32_chip *cpm1_gc = gpiochip_get_data(&mm_gc->gc); 720 struct cpm_ioport32b __iomem *iop = mm_gc->regs; 721 unsigned long flags; 722 u32 pin_mask = 1 << (31 - gpio); 723 724 spin_lock_irqsave(&cpm1_gc->lock, flags); 725 726 setbits32(&iop->dir, pin_mask); 727 __cpm1_gpio32_set(mm_gc, pin_mask, val); 728 729 spin_unlock_irqrestore(&cpm1_gc->lock, flags); 730 731 return 0; 732 } 733 734 static int cpm1_gpio32_dir_in(struct gpio_chip *gc, unsigned int gpio) 735 { 736 struct of_mm_gpio_chip *mm_gc = to_of_mm_gpio_chip(gc); 737 struct cpm1_gpio32_chip *cpm1_gc = gpiochip_get_data(&mm_gc->gc); 738 struct cpm_ioport32b __iomem *iop = mm_gc->regs; 739 unsigned long flags; 740 u32 pin_mask = 1 << (31 - gpio); 741 742 spin_lock_irqsave(&cpm1_gc->lock, flags); 743 744 clrbits32(&iop->dir, pin_mask); 745 746 spin_unlock_irqrestore(&cpm1_gc->lock, flags); 747 748 return 0; 749 } 750 751 int cpm1_gpiochip_add32(struct device *dev) 752 { 753 struct device_node *np = dev->of_node; 754 struct cpm1_gpio32_chip *cpm1_gc; 755 struct of_mm_gpio_chip *mm_gc; 756 struct gpio_chip *gc; 757 758 cpm1_gc = kzalloc(sizeof(*cpm1_gc), GFP_KERNEL); 759 if (!cpm1_gc) 760 return -ENOMEM; 761 762 spin_lock_init(&cpm1_gc->lock); 763 764 mm_gc = &cpm1_gc->mm_gc; 765 gc = &mm_gc->gc; 766 767 mm_gc->save_regs = cpm1_gpio32_save_regs; 768 gc->ngpio = 32; 769 gc->direction_input = cpm1_gpio32_dir_in; 770 gc->direction_output = cpm1_gpio32_dir_out; 771 gc->get = cpm1_gpio32_get; 772 gc->set = cpm1_gpio32_set; 773 gc->parent = dev; 774 gc->owner = THIS_MODULE; 775 776 return of_mm_gpiochip_add_data(np, mm_gc, cpm1_gc); 777 } 778 779 #endif /* CONFIG_8xx_GPIO */ 780