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
8 * Copyright (C) 2009 Cory Maccarrone <darkstar6262@gmail.com>
10 * Based on work done in the linwizard project
11 * Copyright (C) 2008-2009 Angelo Arrifano <miknix@gmail.com>
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.
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.
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.
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>
47 struct i2c_client
*client
;
51 struct gpio_chip chip_out
;
55 struct gpio_chip chip_in
;
61 unsigned int flow_type
;
63 * Work structure to allow for setting values outside of any
64 * possible interrupt context
66 struct work_struct set_val_work
;
75 unsigned int int_reset_gpio_hi
;
76 unsigned int int_reset_gpio_lo
;
79 struct htcpld_chip
*chip
;
83 /* There does not appear to be a way to proactively mask interrupts
84 * on the htcpld chip itself. So, we simply ignore interrupts that
86 static void htcpld_mask(struct irq_data
*data
)
88 struct htcpld_chip
*chip
= irq_data_get_irq_chip_data(data
);
89 chip
->irqs_enabled
&= ~(1 << (data
->irq
- chip
->irq_start
));
90 pr_debug("HTCPLD mask %d %04x\n", data
->irq
, chip
->irqs_enabled
);
92 static void htcpld_unmask(struct irq_data
*data
)
94 struct htcpld_chip
*chip
= irq_data_get_irq_chip_data(data
);
95 chip
->irqs_enabled
|= 1 << (data
->irq
- chip
->irq_start
);
96 pr_debug("HTCPLD unmask %d %04x\n", data
->irq
, chip
->irqs_enabled
);
99 static int htcpld_set_type(struct irq_data
*data
, unsigned int flags
)
101 struct htcpld_chip
*chip
= irq_data_get_irq_chip_data(data
);
103 if (flags
& ~IRQ_TYPE_SENSE_MASK
)
106 /* We only allow edge triggering */
107 if (flags
& (IRQ_TYPE_LEVEL_LOW
|IRQ_TYPE_LEVEL_HIGH
))
110 chip
->flow_type
= flags
;
114 static struct irq_chip htcpld_muxed_chip
= {
116 .irq_mask
= htcpld_mask
,
117 .irq_unmask
= htcpld_unmask
,
118 .irq_set_type
= htcpld_set_type
,
121 /* To properly dispatch IRQ events, we need to read from the
122 * chip. This is an I2C action that could possibly sleep
123 * (which is bad in interrupt context) -- so we use a threaded
124 * interrupt handler to get around that.
126 static irqreturn_t
htcpld_handler(int irq
, void *dev
)
128 struct htcpld_data
*htcpld
= dev
;
134 pr_debug("htcpld is null in ISR\n");
139 * For each chip, do a read of the chip and trigger any interrupts
140 * desired. The interrupts will be triggered from LSB to MSB (i.e.
141 * bit 0 first, then bit 1, etc.)
143 * For chips that have no interrupt range specified, just skip 'em.
145 for (i
= 0; i
< htcpld
->nchips
; i
++) {
146 struct htcpld_chip
*chip
= &htcpld
->chip
[i
];
147 struct i2c_client
*client
;
149 unsigned long uval
, old_val
;
152 pr_debug("chip %d is null in ISR\n", i
);
156 if (chip
->nirqs
== 0)
159 client
= chip
->client
;
161 pr_debug("client %d is null in ISR\n", i
);
166 val
= i2c_smbus_read_byte_data(client
, chip
->cache_out
);
168 /* Throw a warning and skip this chip */
169 dev_warn(chip
->dev
, "Unable to read from chip: %d\n",
174 uval
= (unsigned long)val
;
176 spin_lock_irqsave(&chip
->lock
, flags
);
178 /* Save away the old value so we can compare it */
179 old_val
= chip
->cache_in
;
181 /* Write the new value */
182 chip
->cache_in
= uval
;
184 spin_unlock_irqrestore(&chip
->lock
, flags
);
187 * For each bit in the data (starting at bit 0), trigger
188 * associated interrupts.
190 for (irqpin
= 0; irqpin
< chip
->nirqs
; irqpin
++) {
191 unsigned oldb
, newb
, type
= chip
->flow_type
;
193 irq
= chip
->irq_start
+ irqpin
;
195 /* Run the IRQ handler, but only if the bit value
196 * changed, and the proper flags are set */
197 oldb
= (old_val
>> irqpin
) & 1;
198 newb
= (uval
>> irqpin
) & 1;
200 if ((!oldb
&& newb
&& (type
& IRQ_TYPE_EDGE_RISING
)) ||
201 (oldb
&& !newb
&& (type
& IRQ_TYPE_EDGE_FALLING
))) {
202 pr_debug("fire IRQ %d\n", irqpin
);
203 generic_handle_irq(irq
);
209 * In order to continue receiving interrupts, the int_reset_gpio must
212 if (htcpld
->int_reset_gpio_hi
)
213 gpio_set_value(htcpld
->int_reset_gpio_hi
, 1);
214 if (htcpld
->int_reset_gpio_lo
)
215 gpio_set_value(htcpld
->int_reset_gpio_lo
, 0);
221 * The GPIO set routines can be called from interrupt context, especially if,
222 * for example they're attached to the led-gpio framework and a trigger is
223 * enabled. As such, we declared work above in the htcpld_chip structure,
224 * and that work is scheduled in the set routine. The kernel can then run
225 * the I2C functions, which will sleep, in process context.
227 static void htcpld_chip_set(struct gpio_chip
*chip
, unsigned offset
, int val
)
229 struct i2c_client
*client
;
230 struct htcpld_chip
*chip_data
;
233 chip_data
= container_of(chip
, struct htcpld_chip
, chip_out
);
237 client
= chip_data
->client
;
241 spin_lock_irqsave(&chip_data
->lock
, flags
);
243 chip_data
->cache_out
|= (1 << offset
);
245 chip_data
->cache_out
&= ~(1 << offset
);
246 spin_unlock_irqrestore(&chip_data
->lock
, flags
);
248 schedule_work(&(chip_data
->set_val_work
));
251 static void htcpld_chip_set_ni(struct work_struct
*work
)
253 struct htcpld_chip
*chip_data
;
254 struct i2c_client
*client
;
256 chip_data
= container_of(work
, struct htcpld_chip
, set_val_work
);
257 client
= chip_data
->client
;
258 i2c_smbus_read_byte_data(client
, chip_data
->cache_out
);
261 static int htcpld_chip_get(struct gpio_chip
*chip
, unsigned offset
)
263 struct htcpld_chip
*chip_data
;
268 chip_data
= container_of(chip
, struct htcpld_chip
, chip_out
);
272 chip_data
= container_of(chip
, struct htcpld_chip
, chip_in
);
277 /* Determine if this is an input or output GPIO */
279 /* Use the output cache */
280 val
= (chip_data
->cache_out
>> offset
) & 1;
282 /* Use the input cache */
283 val
= (chip_data
->cache_in
>> offset
) & 1;
291 static int htcpld_direction_output(struct gpio_chip
*chip
,
292 unsigned offset
, int value
)
294 htcpld_chip_set(chip
, offset
, value
);
298 static int htcpld_direction_input(struct gpio_chip
*chip
,
302 * No-op: this function can only be called on the input chip.
303 * We do however make sure the offset is within range.
305 return (offset
< chip
->ngpio
) ? 0 : -EINVAL
;
308 static int htcpld_chip_to_irq(struct gpio_chip
*chip
, unsigned offset
)
310 struct htcpld_chip
*chip_data
;
312 chip_data
= container_of(chip
, struct htcpld_chip
, chip_in
);
314 if (offset
< chip_data
->nirqs
)
315 return chip_data
->irq_start
+ offset
;
320 static void htcpld_chip_reset(struct i2c_client
*client
)
322 struct htcpld_chip
*chip_data
= i2c_get_clientdata(client
);
326 i2c_smbus_read_byte_data(
327 client
, (chip_data
->cache_out
= chip_data
->reset
));
330 static int htcpld_setup_chip_irq(
331 struct platform_device
*pdev
,
334 struct htcpld_data
*htcpld
;
335 struct htcpld_chip
*chip
;
336 unsigned int irq
, irq_end
;
339 /* Get the platform and driver data */
340 htcpld
= platform_get_drvdata(pdev
);
341 chip
= &htcpld
->chip
[chip_index
];
343 /* Setup irq handlers */
344 irq_end
= chip
->irq_start
+ chip
->nirqs
;
345 for (irq
= chip
->irq_start
; irq
< irq_end
; irq
++) {
346 irq_set_chip_and_handler(irq
, &htcpld_muxed_chip
,
348 irq_set_chip_data(irq
, chip
);
350 set_irq_flags(irq
, IRQF_VALID
| IRQF_PROBE
);
359 static int htcpld_register_chip_i2c(
360 struct platform_device
*pdev
,
363 struct htcpld_data
*htcpld
;
364 struct device
*dev
= &pdev
->dev
;
365 struct htcpld_core_platform_data
*pdata
;
366 struct htcpld_chip
*chip
;
367 struct htcpld_chip_platform_data
*plat_chip_data
;
368 struct i2c_adapter
*adapter
;
369 struct i2c_client
*client
;
370 struct i2c_board_info info
;
372 /* Get the platform and driver data */
373 pdata
= dev_get_platdata(dev
);
374 htcpld
= platform_get_drvdata(pdev
);
375 chip
= &htcpld
->chip
[chip_index
];
376 plat_chip_data
= &pdata
->chip
[chip_index
];
378 adapter
= i2c_get_adapter(pdata
->i2c_adapter_id
);
379 if (adapter
== NULL
) {
380 /* Eek, no such I2C adapter! Bail out. */
381 dev_warn(dev
, "Chip at i2c address 0x%x: Invalid i2c adapter %d\n",
382 plat_chip_data
->addr
, pdata
->i2c_adapter_id
);
386 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_READ_BYTE_DATA
)) {
387 dev_warn(dev
, "i2c adapter %d non-functional\n",
388 pdata
->i2c_adapter_id
);
392 memset(&info
, 0, sizeof(struct i2c_board_info
));
393 info
.addr
= plat_chip_data
->addr
;
394 strlcpy(info
.type
, "htcpld-chip", I2C_NAME_SIZE
);
395 info
.platform_data
= chip
;
397 /* Add the I2C device. This calls the probe() function. */
398 client
= i2c_new_device(adapter
, &info
);
400 /* I2C device registration failed, contineu with the next */
401 dev_warn(dev
, "Unable to add I2C device for 0x%x\n",
402 plat_chip_data
->addr
);
406 i2c_set_clientdata(client
, chip
);
407 snprintf(client
->name
, I2C_NAME_SIZE
, "Chip_0x%x", client
->addr
);
408 chip
->client
= client
;
411 htcpld_chip_reset(client
);
412 chip
->cache_in
= i2c_smbus_read_byte_data(client
, chip
->cache_out
);
417 static void htcpld_unregister_chip_i2c(
418 struct platform_device
*pdev
,
421 struct htcpld_data
*htcpld
;
422 struct htcpld_chip
*chip
;
424 /* Get the platform and driver data */
425 htcpld
= platform_get_drvdata(pdev
);
426 chip
= &htcpld
->chip
[chip_index
];
429 i2c_unregister_device(chip
->client
);
432 static int htcpld_register_chip_gpio(
433 struct platform_device
*pdev
,
436 struct htcpld_data
*htcpld
;
437 struct device
*dev
= &pdev
->dev
;
438 struct htcpld_core_platform_data
*pdata
;
439 struct htcpld_chip
*chip
;
440 struct htcpld_chip_platform_data
*plat_chip_data
;
441 struct gpio_chip
*gpio_chip
;
444 /* Get the platform and driver data */
445 pdata
= dev_get_platdata(dev
);
446 htcpld
= platform_get_drvdata(pdev
);
447 chip
= &htcpld
->chip
[chip_index
];
448 plat_chip_data
= &pdata
->chip
[chip_index
];
450 /* Setup the GPIO chips */
451 gpio_chip
= &(chip
->chip_out
);
452 gpio_chip
->label
= "htcpld-out";
453 gpio_chip
->dev
= dev
;
454 gpio_chip
->owner
= THIS_MODULE
;
455 gpio_chip
->get
= htcpld_chip_get
;
456 gpio_chip
->set
= htcpld_chip_set
;
457 gpio_chip
->direction_input
= NULL
;
458 gpio_chip
->direction_output
= htcpld_direction_output
;
459 gpio_chip
->base
= plat_chip_data
->gpio_out_base
;
460 gpio_chip
->ngpio
= plat_chip_data
->num_gpios
;
462 gpio_chip
= &(chip
->chip_in
);
463 gpio_chip
->label
= "htcpld-in";
464 gpio_chip
->dev
= dev
;
465 gpio_chip
->owner
= THIS_MODULE
;
466 gpio_chip
->get
= htcpld_chip_get
;
467 gpio_chip
->set
= NULL
;
468 gpio_chip
->direction_input
= htcpld_direction_input
;
469 gpio_chip
->direction_output
= NULL
;
470 gpio_chip
->to_irq
= htcpld_chip_to_irq
;
471 gpio_chip
->base
= plat_chip_data
->gpio_in_base
;
472 gpio_chip
->ngpio
= plat_chip_data
->num_gpios
;
474 /* Add the GPIO chips */
475 ret
= gpiochip_add(&(chip
->chip_out
));
477 dev_warn(dev
, "Unable to register output GPIOs for 0x%x: %d\n",
478 plat_chip_data
->addr
, ret
);
482 ret
= gpiochip_add(&(chip
->chip_in
));
484 dev_warn(dev
, "Unable to register input GPIOs for 0x%x: %d\n",
485 plat_chip_data
->addr
, ret
);
486 gpiochip_remove(&(chip
->chip_out
));
493 static int htcpld_setup_chips(struct platform_device
*pdev
)
495 struct htcpld_data
*htcpld
;
496 struct device
*dev
= &pdev
->dev
;
497 struct htcpld_core_platform_data
*pdata
;
500 /* Get the platform and driver data */
501 pdata
= dev_get_platdata(dev
);
502 htcpld
= platform_get_drvdata(pdev
);
504 /* Setup each chip's output GPIOs */
505 htcpld
->nchips
= pdata
->num_chip
;
506 htcpld
->chip
= devm_kzalloc(dev
, sizeof(struct htcpld_chip
) * htcpld
->nchips
,
509 dev_warn(dev
, "Unable to allocate memory for chips\n");
513 /* Add the chips as best we can */
514 for (i
= 0; i
< htcpld
->nchips
; i
++) {
517 /* Setup the HTCPLD chips */
518 htcpld
->chip
[i
].reset
= pdata
->chip
[i
].reset
;
519 htcpld
->chip
[i
].cache_out
= pdata
->chip
[i
].reset
;
520 htcpld
->chip
[i
].cache_in
= 0;
521 htcpld
->chip
[i
].dev
= dev
;
522 htcpld
->chip
[i
].irq_start
= pdata
->chip
[i
].irq_base
;
523 htcpld
->chip
[i
].nirqs
= pdata
->chip
[i
].num_irqs
;
525 INIT_WORK(&(htcpld
->chip
[i
].set_val_work
), &htcpld_chip_set_ni
);
526 spin_lock_init(&(htcpld
->chip
[i
].lock
));
528 /* Setup the interrupts for the chip */
529 if (htcpld
->chained_irq
) {
530 ret
= htcpld_setup_chip_irq(pdev
, i
);
535 /* Register the chip with I2C */
536 ret
= htcpld_register_chip_i2c(pdev
, i
);
541 /* Register the chips with the GPIO subsystem */
542 ret
= htcpld_register_chip_gpio(pdev
, i
);
544 /* Unregister the chip from i2c and continue */
545 htcpld_unregister_chip_i2c(pdev
, i
);
549 dev_info(dev
, "Registered chip at 0x%x\n", pdata
->chip
[i
].addr
);
555 static int htcpld_core_probe(struct platform_device
*pdev
)
557 struct htcpld_data
*htcpld
;
558 struct device
*dev
= &pdev
->dev
;
559 struct htcpld_core_platform_data
*pdata
;
560 struct resource
*res
;
566 pdata
= dev_get_platdata(dev
);
568 dev_warn(dev
, "Platform data not found for htcpld core!\n");
572 htcpld
= devm_kzalloc(dev
, sizeof(struct htcpld_data
), GFP_KERNEL
);
576 /* Find chained irq */
577 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
580 htcpld
->chained_irq
= res
->start
;
582 /* Setup the chained interrupt handler */
583 flags
= IRQF_TRIGGER_FALLING
| IRQF_TRIGGER_RISING
;
584 ret
= request_threaded_irq(htcpld
->chained_irq
,
585 NULL
, htcpld_handler
,
586 flags
, pdev
->name
, htcpld
);
588 dev_warn(dev
, "Unable to setup chained irq handler: %d\n", ret
);
591 device_init_wakeup(dev
, 0);
594 /* Set the driver data */
595 platform_set_drvdata(pdev
, htcpld
);
597 /* Setup the htcpld chips */
598 ret
= htcpld_setup_chips(pdev
);
602 /* Request the GPIO(s) for the int reset and set them up */
603 if (pdata
->int_reset_gpio_hi
) {
604 ret
= gpio_request(pdata
->int_reset_gpio_hi
, "htcpld-core");
607 * If it failed, that sucks, but we can probably
608 * continue on without it.
610 dev_warn(dev
, "Unable to request int_reset_gpio_hi -- interrupts may not work\n");
611 htcpld
->int_reset_gpio_hi
= 0;
613 htcpld
->int_reset_gpio_hi
= pdata
->int_reset_gpio_hi
;
614 gpio_set_value(htcpld
->int_reset_gpio_hi
, 1);
618 if (pdata
->int_reset_gpio_lo
) {
619 ret
= gpio_request(pdata
->int_reset_gpio_lo
, "htcpld-core");
622 * If it failed, that sucks, but we can probably
623 * continue on without it.
625 dev_warn(dev
, "Unable to request int_reset_gpio_lo -- interrupts may not work\n");
626 htcpld
->int_reset_gpio_lo
= 0;
628 htcpld
->int_reset_gpio_lo
= pdata
->int_reset_gpio_lo
;
629 gpio_set_value(htcpld
->int_reset_gpio_lo
, 0);
633 dev_info(dev
, "Initialized successfully\n");
637 /* The I2C Driver -- used internally */
638 static const struct i2c_device_id htcpld_chip_id
[] = {
639 { "htcpld-chip", 0 },
642 MODULE_DEVICE_TABLE(i2c
, htcpld_chip_id
);
645 static struct i2c_driver htcpld_chip_driver
= {
647 .name
= "htcpld-chip",
649 .id_table
= htcpld_chip_id
,
652 /* The Core Driver */
653 static struct platform_driver htcpld_core_driver
= {
655 .name
= "i2c-htcpld",
659 static int __init
htcpld_core_init(void)
663 /* Register the I2C Chip driver */
664 ret
= i2c_add_driver(&htcpld_chip_driver
);
668 /* Probe for our chips */
669 return platform_driver_probe(&htcpld_core_driver
, htcpld_core_probe
);
672 static void __exit
htcpld_core_exit(void)
674 i2c_del_driver(&htcpld_chip_driver
);
675 platform_driver_unregister(&htcpld_core_driver
);
678 module_init(htcpld_core_init
);
679 module_exit(htcpld_core_exit
);
681 MODULE_AUTHOR("Cory Maccarrone <darkstar6262@gmail.com>");
682 MODULE_DESCRIPTION("I2C HTC PLD Driver");
683 MODULE_LICENSE("GPL");