Quelle  i2c-viai2c-wmt.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  Wondermedia I2C Controller Driver
 *
 *  Copyright (C) 2012 Tony Prisk <linux@prisktech.co.nz>
 *
 *  Derived from GPLv2+ licensed source:
 *  - Copyright (C) 2008 WonderMedia Technologies, Inc.
 */

#include <linux/clk.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include "i2c-viai2c-common.h"

#define REG_SLAVE_CR 0x10
#define REG_SLAVE_SR 0x12
#define REG_SLAVE_ISR 0x14
#define REG_SLAVE_IMR 0x16
#define REG_SLAVE_DR 0x18
#define REG_SLAVE_TR 0x1A

/* REG_TR */
#define SCL_TIMEOUT(x)  (((x) & 0xFF) << 8)
#define TR_STD   0x0064
#define TR_HS   0x0019

/* REG_MCR */
#define MCR_APB_96M  7
#define MCR_APB_166M  12

static u32 wmt_i2c_func(struct i2c_adapter *adap)
{
 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_NOSTART;
}

static const struct i2c_algorithm wmt_i2c_algo = {
 .xfer = viai2c_xfer,
 .functionality = wmt_i2c_func,
};

static int wmt_i2c_reset_hardware(struct viai2c *i2c)
{
 int err;

 err = clk_prepare_enable(i2c->clk);
 if (err)
  return dev_err_probe(i2c->dev, err, "failed to enable clock\n");

 err = clk_set_rate(i2c->clk, 20000000);
 if (err) {
  clk_disable_unprepare(i2c->clk);
  return dev_err_probe(i2c->dev, err, "failed to set clock = 20Mhz\n");
 }

 writew(0, i2c->base + VIAI2C_REG_CR);
 writew(MCR_APB_166M, i2c->base + VIAI2C_REG_MCR);
 writew(VIAI2C_ISR_MASK_ALL, i2c->base + VIAI2C_REG_ISR);
 writew(VIAI2C_IMR_ENABLE_ALL, i2c->base + VIAI2C_REG_IMR);
 writew(VIAI2C_CR_ENABLE, i2c->base + VIAI2C_REG_CR);
 readw(i2c->base + VIAI2C_REG_CSR);  /* read clear */
 writew(VIAI2C_ISR_MASK_ALL, i2c->base + VIAI2C_REG_ISR);

 if (i2c->tcr == VIAI2C_TCR_FAST)
  writew(SCL_TIMEOUT(128) | TR_HS, i2c->base + VIAI2C_REG_TR);
 else
  writew(SCL_TIMEOUT(128) | TR_STD, i2c->base + VIAI2C_REG_TR);

 return 0;
}

static irqreturn_t wmt_i2c_isr(int irq, void *data)
{
 struct viai2c *i2c = data;
 u8 status;

 /* save the status and write-clear it */
 status = readw(i2c->base + VIAI2C_REG_ISR);
 writew(status, i2c->base + VIAI2C_REG_ISR);

 i2c->ret = 0;
 if (status & VIAI2C_ISR_NACK_ADDR)
  i2c->ret = -EIO;

 if (status & VIAI2C_ISR_SCL_TIMEOUT)
  i2c->ret = -ETIMEDOUT;

 if (!i2c->ret)
  i2c->ret = viai2c_irq_xfer(i2c);

 /* All the data has been successfully transferred or error occurred */
 if (i2c->ret)
  complete(&i2c->complete);

 return IRQ_HANDLED;
}

static int wmt_i2c_probe(struct platform_device *pdev)
{
 struct device_node *np = pdev->dev.of_node;
 struct viai2c *i2c;
 struct i2c_adapter *adap;
 int err;
 u32 clk_rate;

 err = viai2c_init(pdev, &i2c, VIAI2C_PLAT_WMT);
 if (err)
  return err;

 i2c->irq = platform_get_irq(pdev, 0);
 if (i2c->irq < 0)
  return i2c->irq;

 err = devm_request_irq(&pdev->dev, i2c->irq, wmt_i2c_isr,
          0, pdev->name, i2c);
 if (err)
  return dev_err_probe(&pdev->dev, err,
    "failed to request irq %i\n", i2c->irq);

 i2c->clk = of_clk_get(np, 0);
 if (IS_ERR(i2c->clk))
  return dev_err_probe(&pdev->dev, PTR_ERR(i2c->clk),
         "unable to request clock\n");

 err = of_property_read_u32(np, "clock-frequency", &clk_rate);
 if (!err && clk_rate == I2C_MAX_FAST_MODE_FREQ)
  i2c->tcr = VIAI2C_TCR_FAST;

 adap = &i2c->adapter;
 i2c_set_adapdata(adap, i2c);
 strscpy(adap->name, "WMT I2C adapter", sizeof(adap->name));
 adap->owner = THIS_MODULE;
 adap->algo = &wmt_i2c_algo;
 adap->dev.parent = &pdev->dev;
 adap->dev.of_node = pdev->dev.of_node;

 err = wmt_i2c_reset_hardware(i2c);
 if (err)
  return err;

 err = i2c_add_adapter(adap);
 if (err)
  /* wmt_i2c_reset_hardware() enables i2c_dev->clk */
  clk_disable_unprepare(i2c->clk);

 return err;
}

static void wmt_i2c_remove(struct platform_device *pdev)
{
 struct viai2c *i2c = platform_get_drvdata(pdev);

 /* Disable interrupts, clock and delete adapter */
 writew(0, i2c->base + VIAI2C_REG_IMR);
 clk_disable_unprepare(i2c->clk);
 i2c_del_adapter(&i2c->adapter);
}

static const struct of_device_id wmt_i2c_dt_ids[] = {
 { .compatible = "wm,wm8505-i2c" },
 { /* Sentinel */ },
};

static struct platform_driver wmt_i2c_driver = {
 .probe  = wmt_i2c_probe,
 .remove  = wmt_i2c_remove,
 .driver  = {
  .name = "wmt-i2c",
  .of_match_table = wmt_i2c_dt_ids,
 },
};

module_platform_driver(wmt_i2c_driver);

MODULE_DESCRIPTION("Wondermedia I2C controller driver");
MODULE_AUTHOR("Tony Prisk ");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(of, wmt_i2c_dt_ids);