1/* 2 * htc-i2cpld.c 3 * Chip driver for an unknown CPLD chip found on omap850 HTC devices like 4 * the HTC Wizard and HTC Herald. 5 * The cpld is located on the i2c bus and acts as an input/output GPIO 6 * extender. 7 * 8 * Copyright (C) 2009 Cory Maccarrone <darkstar6262@gmail.com> 9 * 10 * Based on work done in the linwizard project 11 * Copyright (C) 2008-2009 Angelo Arrifano <miknix@gmail.com> 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License as published by 15 * the Free Software Foundation; either version 2 of the License, or 16 * (at your option) any later version. 17 * 18 * This program is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * GNU General Public License for more details. 22 * 23 * You should have received a copy of the GNU General Public License 24 * along with this program; if not, write to the Free Software 25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 26 */ 27 28#include <linux/kernel.h> 29#include <linux/init.h> 30#include <linux/module.h> 31#include <linux/interrupt.h> 32#include <linux/platform_device.h> 33#include <linux/i2c.h> 34#include <linux/irq.h> 35#include <linux/spinlock.h> 36#include <linux/htcpld.h> 37#include <linux/gpio.h> 38#include <linux/slab.h> 39 40struct htcpld_chip { 41 spinlock_t lock; 42 43 /* chip info */ 44 u8 reset; 45 u8 addr; 46 struct device *dev; 47 struct i2c_client *client; 48 49 /* Output details */ 50 u8 cache_out; 51 struct gpio_chip chip_out; 52 53 /* Input details */ 54 u8 cache_in; 55 struct gpio_chip chip_in; 56 57 u16 irqs_enabled; 58 uint irq_start; 59 int nirqs; 60 61 /* 62 * Work structure to allow for setting values outside of any 63 * possible interrupt context 64 */ 65 struct work_struct set_val_work; 66}; 67 68struct htcpld_data { 69 /* irq info */ 70 u16 irqs_enabled; 71 uint irq_start; 72 int nirqs; 73 uint chained_irq; 74 unsigned int int_reset_gpio_hi; 75 unsigned int int_reset_gpio_lo; 76 77 /* htcpld info */ 78 struct htcpld_chip *chip; 79 unsigned int nchips; 80}; 81 82/* There does not appear to be a way to proactively mask interrupts 83 * on the htcpld chip itself. So, we simply ignore interrupts that 84 * aren't desired. */ 85static void htcpld_mask(unsigned int irq) 86{ 87 struct htcpld_chip *chip = get_irq_chip_data(irq); 88 chip->irqs_enabled &= ~(1 << (irq - chip->irq_start)); 89 pr_debug("HTCPLD mask %d %04x\n", irq, chip->irqs_enabled); 90} 91static void htcpld_unmask(unsigned int irq) 92{ 93 struct htcpld_chip *chip = get_irq_chip_data(irq); 94 chip->irqs_enabled |= 1 << (irq - chip->irq_start); 95 pr_debug("HTCPLD unmask %d %04x\n", irq, chip->irqs_enabled); 96} 97 98static int htcpld_set_type(unsigned int irq, unsigned int flags) 99{ 100 struct irq_desc *d = irq_to_desc(irq); 101 102 if (!d) { 103 pr_err("HTCPLD invalid IRQ: %d\n", irq); 104 return -EINVAL; 105 } 106 107 if (flags & ~IRQ_TYPE_SENSE_MASK) 108 return -EINVAL; 109 110 /* We only allow edge triggering */ 111 if (flags & (IRQ_TYPE_LEVEL_LOW|IRQ_TYPE_LEVEL_HIGH)) 112 return -EINVAL; 113 114 d->status &= ~IRQ_TYPE_SENSE_MASK; 115 d->status |= flags; 116 117 return 0; 118} 119 120static struct irq_chip htcpld_muxed_chip = { 121 .name = "htcpld", 122 .mask = htcpld_mask, 123 .unmask = htcpld_unmask, 124 .set_type = htcpld_set_type, 125}; 126 127/* To properly dispatch IRQ events, we need to read from the 128 * chip. This is an I2C action that could possibly sleep 129 * (which is bad in interrupt context) -- so we use a threaded 130 * interrupt handler to get around that. 131 */ 132static irqreturn_t htcpld_handler(int irq, void *dev) 133{ 134 struct htcpld_data *htcpld = dev; 135 unsigned int i; 136 unsigned long flags; 137 int irqpin; 138 struct irq_desc *desc; 139 140 if (!htcpld) { 141 pr_debug("htcpld is null in ISR\n"); 142 return IRQ_HANDLED; 143 } 144 145 /* 146 * For each chip, do a read of the chip and trigger any interrupts 147 * desired. The interrupts will be triggered from LSB to MSB (i.e. 148 * bit 0 first, then bit 1, etc.) 149 * 150 * For chips that have no interrupt range specified, just skip 'em. 151 */ 152 for (i = 0; i < htcpld->nchips; i++) { 153 struct htcpld_chip *chip = &htcpld->chip[i]; 154 struct i2c_client *client; 155 int val; 156 unsigned long uval, old_val; 157 158 if (!chip) { 159 pr_debug("chip %d is null in ISR\n", i); 160 continue; 161 } 162 163 if (chip->nirqs == 0) 164 continue; 165 166 client = chip->client; 167 if (!client) { 168 pr_debug("client %d is null in ISR\n", i); 169 continue; 170 } 171 172 /* Scan the chip */ 173 val = i2c_smbus_read_byte_data(client, chip->cache_out); 174 if (val < 0) { 175 /* Throw a warning and skip this chip */ 176 dev_warn(chip->dev, "Unable to read from chip: %d\n", 177 val); 178 continue; 179 } 180 181 uval = (unsigned long)val; 182 183 spin_lock_irqsave(&chip->lock, flags); 184 185 /* Save away the old value so we can compare it */ 186 old_val = chip->cache_in; 187 188 /* Write the new value */ 189 chip->cache_in = uval; 190 191 spin_unlock_irqrestore(&chip->lock, flags); 192 193 /* 194 * For each bit in the data (starting at bit 0), trigger 195 * associated interrupts. 196 */ 197 for (irqpin = 0; irqpin < chip->nirqs; irqpin++) { 198 unsigned oldb, newb; 199 int flags; 200 201 irq = chip->irq_start + irqpin; 202 desc = irq_to_desc(irq); 203 flags = desc->status; 204 205 /* Run the IRQ handler, but only if the bit value 206 * changed, and the proper flags are set */ 207 oldb = (old_val >> irqpin) & 1; 208 newb = (uval >> irqpin) & 1; 209 210 if ((!oldb && newb && (flags & IRQ_TYPE_EDGE_RISING)) || 211 (oldb && !newb && 212 (flags & IRQ_TYPE_EDGE_FALLING))) { 213 pr_debug("fire IRQ %d\n", irqpin); 214 desc->handle_irq(irq, desc); 215 } 216 } 217 } 218 219 /* 220 * In order to continue receiving interrupts, the int_reset_gpio must 221 * be asserted. 222 */ 223 if (htcpld->int_reset_gpio_hi) 224 gpio_set_value(htcpld->int_reset_gpio_hi, 1); 225 if (htcpld->int_reset_gpio_lo) 226 gpio_set_value(htcpld->int_reset_gpio_lo, 0); 227 228 return IRQ_HANDLED; 229} 230 231/* 232 * The GPIO set routines can be called from interrupt context, especially if, 233 * for example they're attached to the led-gpio framework and a trigger is 234 * enabled. As such, we declared work above in the htcpld_chip structure, 235 * and that work is scheduled in the set routine. The kernel can then run 236 * the I2C functions, which will sleep, in process context. 237 */ 238void htcpld_chip_set(struct gpio_chip *chip, unsigned offset, int val) 239{ 240 struct i2c_client *client; 241 struct htcpld_chip *chip_data; 242 unsigned long flags; 243 244 chip_data = container_of(chip, struct htcpld_chip, chip_out); 245 if (!chip_data) 246 return; 247 248 client = chip_data->client; 249 if (client == NULL) 250 return; 251 252 spin_lock_irqsave(&chip_data->lock, flags); 253 if (val) 254 chip_data->cache_out |= (1 << offset); 255 else 256 chip_data->cache_out &= ~(1 << offset); 257 spin_unlock_irqrestore(&chip_data->lock, flags); 258 259 schedule_work(&(chip_data->set_val_work)); 260} 261 262void htcpld_chip_set_ni(struct work_struct *work) 263{ 264 struct htcpld_chip *chip_data; 265 struct i2c_client *client; 266 267 chip_data = container_of(work, struct htcpld_chip, set_val_work); 268 client = chip_data->client; 269 i2c_smbus_read_byte_data(client, chip_data->cache_out); 270} 271 272int htcpld_chip_get(struct gpio_chip *chip, unsigned offset) 273{ 274 struct htcpld_chip *chip_data; 275 int val = 0; 276 int is_input = 0; 277 278 /* Try out first */ 279 chip_data = container_of(chip, struct htcpld_chip, chip_out); 280 if (!chip_data) { 281 /* Try in */ 282 is_input = 1; 283 chip_data = container_of(chip, struct htcpld_chip, chip_in); 284 if (!chip_data) 285 return -EINVAL; 286 } 287 288 /* Determine if this is an input or output GPIO */ 289 if (!is_input) 290 /* Use the output cache */ 291 val = (chip_data->cache_out >> offset) & 1; 292 else 293 /* Use the input cache */ 294 val = (chip_data->cache_in >> offset) & 1; 295 296 if (val) 297 return 1; 298 else 299 return 0; 300} 301 302static int htcpld_direction_output(struct gpio_chip *chip, 303 unsigned offset, int value) 304{ 305 htcpld_chip_set(chip, offset, value); 306 return 0; 307} 308 309static int htcpld_direction_input(struct gpio_chip *chip, 310 unsigned offset) 311{ 312 /* 313 * No-op: this function can only be called on the input chip. 314 * We do however make sure the offset is within range. 315 */ 316 return (offset < chip->ngpio) ? 0 : -EINVAL; 317} 318 319int htcpld_chip_to_irq(struct gpio_chip *chip, unsigned offset) 320{ 321 struct htcpld_chip *chip_data; 322 323 chip_data = container_of(chip, struct htcpld_chip, chip_in); 324 325 if (offset < chip_data->nirqs) 326 return chip_data->irq_start + offset; 327 else 328 return -EINVAL; 329} 330 331void htcpld_chip_reset(struct i2c_client *client) 332{ 333 struct htcpld_chip *chip_data = i2c_get_clientdata(client); 334 if (!chip_data) 335 return; 336 337 i2c_smbus_read_byte_data( 338 client, (chip_data->cache_out = chip_data->reset)); 339} 340 341static int __devinit htcpld_setup_chip_irq( 342 struct platform_device *pdev, 343 int chip_index) 344{ 345 struct htcpld_data *htcpld; 346 struct device *dev = &pdev->dev; 347 struct htcpld_core_platform_data *pdata; 348 struct htcpld_chip *chip; 349 struct htcpld_chip_platform_data *plat_chip_data; 350 unsigned int irq, irq_end; 351 int ret = 0; 352 353 /* Get the platform and driver data */ 354 pdata = dev->platform_data; 355 htcpld = platform_get_drvdata(pdev); 356 chip = &htcpld->chip[chip_index]; 357 plat_chip_data = &pdata->chip[chip_index]; 358 359 /* Setup irq handlers */ 360 irq_end = chip->irq_start + chip->nirqs; 361 for (irq = chip->irq_start; irq < irq_end; irq++) { 362 set_irq_chip(irq, &htcpld_muxed_chip); 363 set_irq_chip_data(irq, chip); 364 set_irq_handler(irq, handle_simple_irq); 365#ifdef CONFIG_ARM 366 set_irq_flags(irq, IRQF_VALID | IRQF_PROBE); 367#else 368 set_irq_probe(irq); 369#endif 370 } 371 372 return ret; 373} 374 375static int __devinit htcpld_register_chip_i2c( 376 struct platform_device *pdev, 377 int chip_index) 378{ 379 struct htcpld_data *htcpld; 380 struct device *dev = &pdev->dev; 381 struct htcpld_core_platform_data *pdata; 382 struct htcpld_chip *chip; 383 struct htcpld_chip_platform_data *plat_chip_data; 384 struct i2c_adapter *adapter; 385 struct i2c_client *client; 386 struct i2c_board_info info; 387 388 /* Get the platform and driver data */ 389 pdata = dev->platform_data; 390 htcpld = platform_get_drvdata(pdev); 391 chip = &htcpld->chip[chip_index]; 392 plat_chip_data = &pdata->chip[chip_index]; 393 394 adapter = i2c_get_adapter(pdata->i2c_adapter_id); 395 if (adapter == NULL) { 396 /* Eek, no such I2C adapter! Bail out. */ 397 dev_warn(dev, "Chip at i2c address 0x%x: Invalid i2c adapter %d\n", 398 plat_chip_data->addr, pdata->i2c_adapter_id); 399 return -ENODEV; 400 } 401 402 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA)) { 403 dev_warn(dev, "i2c adapter %d non-functional\n", 404 pdata->i2c_adapter_id); 405 return -EINVAL; 406 } 407 408 memset(&info, 0, sizeof(struct i2c_board_info)); 409 info.addr = plat_chip_data->addr; 410 strlcpy(info.type, "htcpld-chip", I2C_NAME_SIZE); 411 info.platform_data = chip; 412 413 /* Add the I2C device. This calls the probe() function. */ 414 client = i2c_new_device(adapter, &info); 415 if (!client) { 416 /* I2C device registration failed, contineu with the next */ 417 dev_warn(dev, "Unable to add I2C device for 0x%x\n", 418 plat_chip_data->addr); 419 return -ENODEV; 420 } 421 422 i2c_set_clientdata(client, chip); 423 snprintf(client->name, I2C_NAME_SIZE, "Chip_0x%d", client->addr); 424 chip->client = client; 425 426 /* Reset the chip */ 427 htcpld_chip_reset(client); 428 chip->cache_in = i2c_smbus_read_byte_data(client, chip->cache_out); 429 430 return 0; 431} 432 433static void __devinit htcpld_unregister_chip_i2c( 434 struct platform_device *pdev, 435 int chip_index) 436{ 437 struct htcpld_data *htcpld; 438 struct htcpld_chip *chip; 439 440 /* Get the platform and driver data */ 441 htcpld = platform_get_drvdata(pdev); 442 chip = &htcpld->chip[chip_index]; 443 444 if (chip->client) 445 i2c_unregister_device(chip->client); 446} 447 448static int __devinit htcpld_register_chip_gpio( 449 struct platform_device *pdev, 450 int chip_index) 451{ 452 struct htcpld_data *htcpld; 453 struct device *dev = &pdev->dev; 454 struct htcpld_core_platform_data *pdata; 455 struct htcpld_chip *chip; 456 struct htcpld_chip_platform_data *plat_chip_data; 457 struct gpio_chip *gpio_chip; 458 int ret = 0; 459 460 /* Get the platform and driver data */ 461 pdata = dev->platform_data; 462 htcpld = platform_get_drvdata(pdev); 463 chip = &htcpld->chip[chip_index]; 464 plat_chip_data = &pdata->chip[chip_index]; 465 466 /* Setup the GPIO chips */ 467 gpio_chip = &(chip->chip_out); 468 gpio_chip->label = "htcpld-out"; 469 gpio_chip->dev = dev; 470 gpio_chip->owner = THIS_MODULE; 471 gpio_chip->get = htcpld_chip_get; 472 gpio_chip->set = htcpld_chip_set; 473 gpio_chip->direction_input = NULL; 474 gpio_chip->direction_output = htcpld_direction_output; 475 gpio_chip->base = plat_chip_data->gpio_out_base; 476 gpio_chip->ngpio = plat_chip_data->num_gpios; 477 478 gpio_chip = &(chip->chip_in); 479 gpio_chip->label = "htcpld-in"; 480 gpio_chip->dev = dev; 481 gpio_chip->owner = THIS_MODULE; 482 gpio_chip->get = htcpld_chip_get; 483 gpio_chip->set = NULL; 484 gpio_chip->direction_input = htcpld_direction_input; 485 gpio_chip->direction_output = NULL; 486 gpio_chip->to_irq = htcpld_chip_to_irq; 487 gpio_chip->base = plat_chip_data->gpio_in_base; 488 gpio_chip->ngpio = plat_chip_data->num_gpios; 489 490 /* Add the GPIO chips */ 491 ret = gpiochip_add(&(chip->chip_out)); 492 if (ret) { 493 dev_warn(dev, "Unable to register output GPIOs for 0x%x: %d\n", 494 plat_chip_data->addr, ret); 495 return ret; 496 } 497 498 ret = gpiochip_add(&(chip->chip_in)); 499 if (ret) { 500 int error; 501 502 dev_warn(dev, "Unable to register input GPIOs for 0x%x: %d\n", 503 plat_chip_data->addr, ret); 504 505 error = gpiochip_remove(&(chip->chip_out)); 506 if (error) 507 dev_warn(dev, "Error while trying to unregister gpio chip: %d\n", error); 508 509 return ret; 510 } 511 512 return 0; 513} 514 515static int __devinit htcpld_setup_chips(struct platform_device *pdev) 516{ 517 struct htcpld_data *htcpld; 518 struct device *dev = &pdev->dev; 519 struct htcpld_core_platform_data *pdata; 520 int i; 521 522 /* Get the platform and driver data */ 523 pdata = dev->platform_data; 524 htcpld = platform_get_drvdata(pdev); 525 526 /* Setup each chip's output GPIOs */ 527 htcpld->nchips = pdata->num_chip; 528 htcpld->chip = kzalloc(sizeof(struct htcpld_chip) * htcpld->nchips, 529 GFP_KERNEL); 530 if (!htcpld->chip) { 531 dev_warn(dev, "Unable to allocate memory for chips\n"); 532 return -ENOMEM; 533 } 534 535 /* Add the chips as best we can */ 536 for (i = 0; i < htcpld->nchips; i++) { 537 int ret; 538 539 /* Setup the HTCPLD chips */ 540 htcpld->chip[i].reset = pdata->chip[i].reset; 541 htcpld->chip[i].cache_out = pdata->chip[i].reset; 542 htcpld->chip[i].cache_in = 0; 543 htcpld->chip[i].dev = dev; 544 htcpld->chip[i].irq_start = pdata->chip[i].irq_base; 545 htcpld->chip[i].nirqs = pdata->chip[i].num_irqs; 546 547 INIT_WORK(&(htcpld->chip[i].set_val_work), &htcpld_chip_set_ni); 548 spin_lock_init(&(htcpld->chip[i].lock)); 549 550 /* Setup the interrupts for the chip */ 551 if (htcpld->chained_irq) { 552 ret = htcpld_setup_chip_irq(pdev, i); 553 if (ret) 554 continue; 555 } 556 557 /* Register the chip with I2C */ 558 ret = htcpld_register_chip_i2c(pdev, i); 559 if (ret) 560 continue; 561 562 563 /* Register the chips with the GPIO subsystem */ 564 ret = htcpld_register_chip_gpio(pdev, i); 565 if (ret) { 566 /* Unregister the chip from i2c and continue */ 567 htcpld_unregister_chip_i2c(pdev, i); 568 continue; 569 } 570 571 dev_info(dev, "Registered chip at 0x%x\n", pdata->chip[i].addr); 572 } 573 574 return 0; 575} 576 577static int __devinit htcpld_core_probe(struct platform_device *pdev) 578{ 579 struct htcpld_data *htcpld; 580 struct device *dev = &pdev->dev; 581 struct htcpld_core_platform_data *pdata; 582 struct resource *res; 583 int ret = 0; 584 585 if (!dev) 586 return -ENODEV; 587 588 pdata = dev->platform_data; 589 if (!pdata) { 590 dev_warn(dev, "Platform data not found for htcpld core!\n"); 591 return -ENXIO; 592 } 593 594 htcpld = kzalloc(sizeof(struct htcpld_data), GFP_KERNEL); 595 if (!htcpld) 596 return -ENOMEM; 597 598 /* Find chained irq */ 599 ret = -EINVAL; 600 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 601 if (res) { 602 int flags; 603 htcpld->chained_irq = res->start; 604 605 /* Setup the chained interrupt handler */ 606 flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING; 607 ret = request_threaded_irq(htcpld->chained_irq, 608 NULL, htcpld_handler, 609 flags, pdev->name, htcpld); 610 if (ret) { 611 dev_warn(dev, "Unable to setup chained irq handler: %d\n", ret); 612 goto fail; 613 } else 614 device_init_wakeup(dev, 0); 615 } 616 617 /* Set the driver data */ 618 platform_set_drvdata(pdev, htcpld); 619 620 /* Setup the htcpld chips */ 621 ret = htcpld_setup_chips(pdev); 622 if (ret) 623 goto fail; 624 625 /* Request the GPIO(s) for the int reset and set them up */ 626 if (pdata->int_reset_gpio_hi) { 627 ret = gpio_request(pdata->int_reset_gpio_hi, "htcpld-core"); 628 if (ret) { 629 /* 630 * If it failed, that sucks, but we can probably 631 * continue on without it. 632 */ 633 dev_warn(dev, "Unable to request int_reset_gpio_hi -- interrupts may not work\n"); 634 htcpld->int_reset_gpio_hi = 0; 635 } else { 636 htcpld->int_reset_gpio_hi = pdata->int_reset_gpio_hi; 637 gpio_set_value(htcpld->int_reset_gpio_hi, 1); 638 } 639 } 640 641 if (pdata->int_reset_gpio_lo) { 642 ret = gpio_request(pdata->int_reset_gpio_lo, "htcpld-core"); 643 if (ret) { 644 /* 645 * If it failed, that sucks, but we can probably 646 * continue on without it. 647 */ 648 dev_warn(dev, "Unable to request int_reset_gpio_lo -- interrupts may not work\n"); 649 htcpld->int_reset_gpio_lo = 0; 650 } else { 651 htcpld->int_reset_gpio_lo = pdata->int_reset_gpio_lo; 652 gpio_set_value(htcpld->int_reset_gpio_lo, 0); 653 } 654 } 655 656 dev_info(dev, "Initialized successfully\n"); 657 return 0; 658 659fail: 660 kfree(htcpld); 661 return ret; 662} 663 664/* The I2C Driver -- used internally */ 665static const struct i2c_device_id htcpld_chip_id[] = { 666 { "htcpld-chip", 0 }, 667 { } 668}; 669MODULE_DEVICE_TABLE(i2c, htcpld_chip_id); 670 671 672static struct i2c_driver htcpld_chip_driver = { 673 .driver = { 674 .name = "htcpld-chip", 675 }, 676 .id_table = htcpld_chip_id, 677}; 678 679/* The Core Driver */ 680static struct platform_driver htcpld_core_driver = { 681 .driver = { 682 .name = "i2c-htcpld", 683 }, 684}; 685 686static int __init htcpld_core_init(void) 687{ 688 int ret; 689 690 /* Register the I2C Chip driver */ 691 ret = i2c_add_driver(&htcpld_chip_driver); 692 if (ret) 693 return ret; 694 695 /* Probe for our chips */ 696 return platform_driver_probe(&htcpld_core_driver, htcpld_core_probe); 697} 698 699static void __exit htcpld_core_exit(void) 700{ 701 i2c_del_driver(&htcpld_chip_driver); 702 platform_driver_unregister(&htcpld_core_driver); 703} 704 705module_init(htcpld_core_init); 706module_exit(htcpld_core_exit); 707 708MODULE_AUTHOR("Cory Maccarrone <darkstar6262@gmail.com>"); 709MODULE_DESCRIPTION("I2C HTC PLD Driver"); 710MODULE_LICENSE("GPL"); 711