/*
   * wm831x-auxadc.c  --  AUXADC for Wolfson WM831x PMICs
   *
   * Copyright 2009-2011 Wolfson Microelectronics PLC.
   *
   * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   *
   *  This program is free software; you can redistribute  it and/or modify it
   *  under  the terms of  the GNU General  Public License as published by the
   *  Free Software Foundation;  either version 2 of the  License, or (at your
   *  option) any later version.
   *
   */
  
  #include <linux/kernel.h>
  #include <linux/module.h>
  #include <linux/delay.h>
  #include <linux/mfd/core.h>
  #include <linux/slab.h>

  #include <linux/list.h>

  
  #include <linux/mfd/wm831x/core.h>
  #include <linux/mfd/wm831x/pdata.h>
  #include <linux/mfd/wm831x/irq.h>
  #include <linux/mfd/wm831x/auxadc.h>
  #include <linux/mfd/wm831x/otp.h>
  #include <linux/mfd/wm831x/regulator.h>

  struct wm831x_auxadc_req {
  	struct list_head list;
  	enum wm831x_auxadc input;
  	int val;
  	struct completion done;
  };
  
  static int wm831x_auxadc_read_irq(struct wm831x *wm831x,
  				  enum wm831x_auxadc input)

  {

  	struct wm831x_auxadc_req *req;
  	int ret;
  	bool ena = false;
  
  	req = kzalloc(sizeof(*req), GFP_KERNEL);
  	if (!req)
  		return -ENOMEM;
  
  	init_completion(&req->done);
  	req->input = input;
  	req->val = -ETIMEDOUT;
  
  	mutex_lock(&wm831x->auxadc_lock);
  
  	/* Enqueue the request */
  	list_add(&req->list, &wm831x->auxadc_pending);
  
  	ena = !wm831x->auxadc_active;
  
  	if (ena) {
  		ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
  				      WM831X_AUX_ENA, WM831X_AUX_ENA);
  		if (ret != 0) {
  			dev_err(wm831x->dev, "Failed to enable AUXADC: %d
  ",
  				ret);
  			goto out;
  		}
  	}
  
  	/* Enable the conversion if not already running */
  	if (!(wm831x->auxadc_active & (1 << input))) {
  		ret = wm831x_set_bits(wm831x, WM831X_AUXADC_SOURCE,
  				      1 << input, 1 << input);
  		if (ret != 0) {
  			dev_err(wm831x->dev,
  				"Failed to set AUXADC source: %d
  ", ret);
  			goto out;
  		}
  
  		wm831x->auxadc_active |= 1 << input;
  	}
  
  	/* We convert at the fastest rate possible */
  	if (ena) {
  		ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
  				      WM831X_AUX_CVT_ENA |
  				      WM831X_AUX_RATE_MASK,
  				      WM831X_AUX_CVT_ENA |
  				      WM831X_AUX_RATE_MASK);
  		if (ret != 0) {
  			dev_err(wm831x->dev, "Failed to start AUXADC: %d
  ",
  				ret);
  			goto out;
  		}
  	}
  
  	mutex_unlock(&wm831x->auxadc_lock);
  
  	/* Wait for an interrupt */
  	wait_for_completion_timeout(&req->done, msecs_to_jiffies(500));
  
  	mutex_lock(&wm831x->auxadc_lock);
  
  	list_del(&req->list);
  	ret = req->val;
  
  out:
  	mutex_unlock(&wm831x->auxadc_lock);
  
  	kfree(req);
  
  	return ret;
  }
  
  static irqreturn_t wm831x_auxadc_irq(int irq, void *irq_data)
  {
  	struct wm831x *wm831x = irq_data;
  	struct wm831x_auxadc_req *req;
  	int ret, input, val;
  
  	ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
  	if (ret < 0) {
  		dev_err(wm831x->dev,
  			"Failed to read AUXADC data: %d
  ", ret);
  		return IRQ_NONE;
  	}
  
  	input = ((ret & WM831X_AUX_DATA_SRC_MASK)
  		 >> WM831X_AUX_DATA_SRC_SHIFT) - 1;
  
  	if (input == 14)
  		input = WM831X_AUX_CAL;

  	val = ret & WM831X_AUX_DATA_MASK;
  
  	mutex_lock(&wm831x->auxadc_lock);
  
  	/* Disable this conversion, we're about to complete all users */
  	wm831x_set_bits(wm831x, WM831X_AUXADC_SOURCE,
  			1 << input, 0);
  	wm831x->auxadc_active &= ~(1 << input);
  
  	/* Turn off the entire convertor if idle */
  	if (!wm831x->auxadc_active)
  		wm831x_reg_write(wm831x, WM831X_AUXADC_CONTROL, 0);
  
  	/* Wake up any threads waiting for this request */
  	list_for_each_entry(req, &wm831x->auxadc_pending, list) {
  		if (req->input == input) {
  			req->val = val;
  			complete(&req->done);
  		}
  	}
  
  	mutex_unlock(&wm831x->auxadc_lock);
  
  	return IRQ_HANDLED;
  }
  
  static int wm831x_auxadc_read_polled(struct wm831x *wm831x,
  				     enum wm831x_auxadc input)
  {
  	int ret, src, timeout;

  
  	mutex_lock(&wm831x->auxadc_lock);
  
  	ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
  			      WM831X_AUX_ENA, WM831X_AUX_ENA);
  	if (ret < 0) {
  		dev_err(wm831x->dev, "Failed to enable AUXADC: %d
  ", ret);
  		goto out;
  	}
  
  	/* We force a single source at present */
  	src = input;
  	ret = wm831x_reg_write(wm831x, WM831X_AUXADC_SOURCE,
  			       1 << src);
  	if (ret < 0) {
  		dev_err(wm831x->dev, "Failed to set AUXADC source: %d
  ", ret);
  		goto out;
  	}

  	ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
  			      WM831X_AUX_CVT_ENA, WM831X_AUX_CVT_ENA);
  	if (ret < 0) {
  		dev_err(wm831x->dev, "Failed to start AUXADC: %d
  ", ret);
  		goto disable;
  	}

  	/* If we're not using interrupts then poll the
  	 * interrupt status register */
  	timeout = 5;
  	while (timeout) {
  		msleep(1);

  		ret = wm831x_reg_read(wm831x,
  				      WM831X_INTERRUPT_STATUS_1);

  		if (ret < 0) {
  			dev_err(wm831x->dev,

  				"ISR 1 read failed: %d
  ", ret);

  			goto disable;
  		}

  		/* Did it complete? */
  		if (ret & WM831X_AUXADC_DATA_EINT) {
  			wm831x_reg_write(wm831x,
  					 WM831X_INTERRUPT_STATUS_1,
  					 WM831X_AUXADC_DATA_EINT);
  			break;
  		} else {
  			dev_err(wm831x->dev,
  				"AUXADC conversion timeout
  ");

  			ret = -EBUSY;
  			goto disable;
  		}
  	}

  	ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
  	if (ret < 0) {
  		dev_err(wm831x->dev,
  			"Failed to read AUXADC data: %d
  ", ret);
  		goto disable;
  	}
  
  	src = ((ret & WM831X_AUX_DATA_SRC_MASK)

  	       >> WM831X_AUX_DATA_SRC_SHIFT) - 1;
  
  	if (src == 14)
  		src = WM831X_AUX_CAL;
  
  	if (src != input) {
  		dev_err(wm831x->dev, "Data from source %d not %d
  ",
  			src, input);
  		ret = -EINVAL;
  	} else {

  		ret &= WM831X_AUX_DATA_MASK;

  	}
  
  disable:
  	wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL, WM831X_AUX_ENA, 0);
  out:
  	mutex_unlock(&wm831x->auxadc_lock);
  	return ret;
  }

  /**
   * wm831x_auxadc_read: Read a value from the WM831x AUXADC
   *
   * @wm831x: Device to read from.
   * @input: AUXADC input to read.
   */
  int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)

  {

  	return wm831x->auxadc_read(wm831x, input);

  }

  EXPORT_SYMBOL_GPL(wm831x_auxadc_read);

  
  /**
   * wm831x_auxadc_read_uv: Read a voltage from the WM831x AUXADC
   *
   * @wm831x: Device to read from.
   * @input: AUXADC input to read.
   */
  int wm831x_auxadc_read_uv(struct wm831x *wm831x, enum wm831x_auxadc input)
  {
  	int ret;
  
  	ret = wm831x_auxadc_read(wm831x, input);
  	if (ret < 0)
  		return ret;
  
  	ret *= 1465;
  
  	return ret;
  }
  EXPORT_SYMBOL_GPL(wm831x_auxadc_read_uv);
  
  void wm831x_auxadc_init(struct wm831x *wm831x)
  {
  	int ret;
  
  	mutex_init(&wm831x->auxadc_lock);

  	INIT_LIST_HEAD(&wm831x->auxadc_pending);
  
  	if (wm831x->irq && wm831x->irq_base) {
  		wm831x->auxadc_read = wm831x_auxadc_read_irq;

  		ret = request_threaded_irq(wm831x->irq_base +
  					   WM831X_IRQ_AUXADC_DATA,
  					   NULL, wm831x_auxadc_irq, 0,
  					   "auxadc", wm831x);

  		if (ret < 0) {

  			dev_err(wm831x->dev, "AUXADC IRQ request failed: %d
  ",
  				ret);

  			wm831x->auxadc_read = NULL;
  		}

  	}

  
  	if (!wm831x->auxadc_read)
  		wm831x->auxadc_read = wm831x_auxadc_read_polled;

  }