rc/img-ir/img-ir-core.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * ImgTec IR Decoder found in PowerDown Controller.
0004  *
0005  * Copyright 2010-2014 Imagination Technologies Ltd.
0006  *
0007  * This contains core img-ir code for setting up the driver. The two interfaces
0008  * (raw and hardware decode) are handled separately.
0009  */
0010
0011 #include <linux/clk.h>
0012 #include <linux/init.h>
0013 #include <linux/interrupt.h>
0014 #include <linux/io.h>
0015 #include <linux/module.h>
0016 #include <linux/platform_device.h>
0017 #include <linux/slab.h>
0018 #include <linux/spinlock.h>
0019 #include "img-ir.h"
0020
0021 static irqreturn_t img_ir_isr(int irq, void *dev_id)
0022 {
0023     struct img_ir_priv *priv = dev_id;
0024     u32 irq_status;
0025
0026     spin_lock(&priv->lock);
0027     /* we have to clear irqs before reading */
0028     irq_status = img_ir_read(priv, IMG_IR_IRQ_STATUS);
0029     img_ir_write(priv, IMG_IR_IRQ_CLEAR, irq_status);
0030
0031     /* don't handle valid data irqs if we're only interested in matches */
0032     irq_status &= img_ir_read(priv, IMG_IR_IRQ_ENABLE);
0033
0034     /* hand off edge interrupts to raw decode handler */
0035     if (irq_status & IMG_IR_IRQ_EDGE && img_ir_raw_enabled(&priv->raw))
0036         img_ir_isr_raw(priv, irq_status);
0037
0038     /* hand off hardware match interrupts to hardware decode handler */
0039     if (irq_status & (IMG_IR_IRQ_DATA_MATCH |
0040               IMG_IR_IRQ_DATA_VALID |
0041               IMG_IR_IRQ_DATA2_VALID) &&
0042         img_ir_hw_enabled(&priv->hw))
0043         img_ir_isr_hw(priv, irq_status);
0044
0045     spin_unlock(&priv->lock);
0046     return IRQ_HANDLED;
0047 }
0048
0049 static void img_ir_setup(struct img_ir_priv *priv)
0050 {
0051     /* start off with interrupts disabled */
0052     img_ir_write(priv, IMG_IR_IRQ_ENABLE, 0);
0053
0054     img_ir_setup_raw(priv);
0055     img_ir_setup_hw(priv);
0056
0057     if (!IS_ERR(priv->clk))
0058         clk_prepare_enable(priv->clk);
0059 }
0060
0061 static void img_ir_ident(struct img_ir_priv *priv)
0062 {
0063     u32 core_rev = img_ir_read(priv, IMG_IR_CORE_REV);
0064
0065     dev_info(priv->dev,
0066          "IMG IR Decoder (%d.%d.%d.%d) probed successfully\n",
0067          (core_rev & IMG_IR_DESIGNER) >> IMG_IR_DESIGNER_SHIFT,
0068          (core_rev & IMG_IR_MAJOR_REV) >> IMG_IR_MAJOR_REV_SHIFT,
0069          (core_rev & IMG_IR_MINOR_REV) >> IMG_IR_MINOR_REV_SHIFT,
0070          (core_rev & IMG_IR_MAINT_REV) >> IMG_IR_MAINT_REV_SHIFT);
0071     dev_info(priv->dev, "Modes:%s%s\n",
0072          img_ir_hw_enabled(&priv->hw) ? " hardware" : "",
0073          img_ir_raw_enabled(&priv->raw) ? " raw" : "");
0074 }
0075
0076 static int img_ir_probe(struct platform_device *pdev)
0077 {
0078     struct img_ir_priv *priv;
0079     int irq, error, error2;
0080
0081     /* Get resources from platform device */
0082     irq = platform_get_irq(pdev, 0);
0083     if (irq < 0)
0084         return irq;
0085
0086     /* Private driver data */
0087     priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
0088     if (!priv)
0089         return -ENOMEM;
0090
0091     platform_set_drvdata(pdev, priv);
0092     priv->dev = &pdev->dev;
0093     spin_lock_init(&priv->lock);
0094
0095     /* Ioremap the registers */
0096     priv->reg_base = devm_platform_ioremap_resource(pdev, 0);
0097     if (IS_ERR(priv->reg_base))
0098         return PTR_ERR(priv->reg_base);
0099
0100     /* Get core clock */
0101     priv->clk = devm_clk_get(&pdev->dev, "core");
0102     if (IS_ERR(priv->clk))
0103         dev_warn(&pdev->dev, "cannot get core clock resource\n");
0104
0105     /* Get sys clock */
0106     priv->sys_clk = devm_clk_get(&pdev->dev, "sys");
0107     if (IS_ERR(priv->sys_clk))
0108         dev_warn(&pdev->dev, "cannot get sys clock resource\n");
0109     /*
0110      * Enabling the system clock before the register interface is
0111      * accessed. ISR shouldn't get called with Sys Clock disabled,
0112      * hence exiting probe with an error.
0113      */
0114     if (!IS_ERR(priv->sys_clk)) {
0115         error = clk_prepare_enable(priv->sys_clk);
0116         if (error) {
0117             dev_err(&pdev->dev, "cannot enable sys clock\n");
0118             return error;
0119         }
0120     }
0121
0122     /* Set up raw & hw decoder */
0123     error = img_ir_probe_raw(priv);
0124     error2 = img_ir_probe_hw(priv);
0125     if (error && error2) {
0126         if (error == -ENODEV)
0127             error = error2;
0128         goto err_probe;
0129     }
0130
0131     /* Get the IRQ */
0132     priv->irq = irq;
0133     error = request_irq(priv->irq, img_ir_isr, 0, "img-ir", priv);
0134     if (error) {
0135         dev_err(&pdev->dev, "cannot register IRQ %u\n",
0136             priv->irq);
0137         error = -EIO;
0138         goto err_irq;
0139     }
0140
0141     img_ir_ident(priv);
0142     img_ir_setup(priv);
0143
0144     return 0;
0145
0146 err_irq:
0147     img_ir_remove_hw(priv);
0148     img_ir_remove_raw(priv);
0149 err_probe:
0150     if (!IS_ERR(priv->sys_clk))
0151         clk_disable_unprepare(priv->sys_clk);
0152     return error;
0153 }
0154
0155 static int img_ir_remove(struct platform_device *pdev)
0156 {
0157     struct img_ir_priv *priv = platform_get_drvdata(pdev);
0158
0159     free_irq(priv->irq, priv);
0160     img_ir_remove_hw(priv);
0161     img_ir_remove_raw(priv);
0162
0163     if (!IS_ERR(priv->clk))
0164         clk_disable_unprepare(priv->clk);
0165     if (!IS_ERR(priv->sys_clk))
0166         clk_disable_unprepare(priv->sys_clk);
0167     return 0;
0168 }
0169
0170 static SIMPLE_DEV_PM_OPS(img_ir_pmops, img_ir_suspend, img_ir_resume);
0171
0172 static const struct of_device_id img_ir_match[] = {
0173     { .compatible = "img,ir-rev1" },
0174     {}
0175 };
0176 MODULE_DEVICE_TABLE(of, img_ir_match);
0177
0178 static struct platform_driver img_ir_driver = {
0179     .driver = {
0180         .name = "img-ir",
0181         .of_match_table = img_ir_match,
0182         .pm = &img_ir_pmops,
0183     },
0184     .probe = img_ir_probe,
0185     .remove = img_ir_remove,
0186 };
0187
0188 module_platform_driver(img_ir_driver);
0189
0190 MODULE_AUTHOR("Imagination Technologies Ltd.");
0191 MODULE_DESCRIPTION("ImgTec IR");
0192 MODULE_LICENSE("GPL");