/*
   * Intel MIC Platform Software Stack (MPSS)
   *
   * Copyright(c) 2013 Intel Corporation.
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License, version 2, as
   * published by the Free Software Foundation.
   *
   * This program is distributed in the hope that it will be useful, but
   * WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   * General Public License for more details.
   *
   * The full GNU General Public License is included in this distribution in
   * the file called "COPYING".
   *
   * Intel MIC Host driver.
   *
   */
  #include <linux/delay.h>
  #include <linux/firmware.h>
  #include <linux/pci.h>
  #include <linux/kmod.h>
  #include <linux/mic_common.h>
  #include <linux/mic_bus.h>
  #include "../bus/scif_bus.h"
  #include "../common/mic_dev.h"
  #include "mic_device.h"
  #include "mic_smpt.h"
  #include "mic_virtio.h"
  
  static inline struct mic_device *scdev_to_mdev(struct scif_hw_dev *scdev)
  {
  	return dev_get_drvdata(scdev->dev.parent);
  }
  
  static void *__mic_dma_alloc(struct device *dev, size_t size,
  			     dma_addr_t *dma_handle, gfp_t gfp,
  			     struct dma_attrs *attrs)
  {
  	struct scif_hw_dev *scdev = dev_get_drvdata(dev);
  	struct mic_device *mdev = scdev_to_mdev(scdev);
  	dma_addr_t tmp;
  	void *va = kmalloc(size, gfp);
  
  	if (va) {
  		tmp = mic_map_single(mdev, va, size);
  		if (dma_mapping_error(dev, tmp)) {
  			kfree(va);
  			va = NULL;
  		} else {
  			*dma_handle = tmp;
  		}
  	}
  	return va;
  }
  
  static void __mic_dma_free(struct device *dev, size_t size, void *vaddr,
  			   dma_addr_t dma_handle, struct dma_attrs *attrs)
  {
  	struct scif_hw_dev *scdev = dev_get_drvdata(dev);
  	struct mic_device *mdev = scdev_to_mdev(scdev);
  
  	mic_unmap_single(mdev, dma_handle, size);
  	kfree(vaddr);
  }
  
  static dma_addr_t
  __mic_dma_map_page(struct device *dev, struct page *page, unsigned long offset,
  		   size_t size, enum dma_data_direction dir,
  		   struct dma_attrs *attrs)
  {
  	void *va = phys_to_virt(page_to_phys(page)) + offset;
  	struct scif_hw_dev *scdev = dev_get_drvdata(dev);
  	struct mic_device *mdev = scdev_to_mdev(scdev);
  
  	return mic_map_single(mdev, va, size);
  }
  
  static void
  __mic_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
  		     size_t size, enum dma_data_direction dir,
  		     struct dma_attrs *attrs)
  {
  	struct scif_hw_dev *scdev = dev_get_drvdata(dev);
  	struct mic_device *mdev = scdev_to_mdev(scdev);
  
  	mic_unmap_single(mdev, dma_addr, size);
  }
  
  static int __mic_dma_map_sg(struct device *dev, struct scatterlist *sg,
  			    int nents, enum dma_data_direction dir,
  			    struct dma_attrs *attrs)
  {
  	struct scif_hw_dev *scdev = dev_get_drvdata(dev);
  	struct mic_device *mdev = scdev_to_mdev(scdev);
  	struct scatterlist *s;
  	int i, j, ret;
  	dma_addr_t da;
  
  	ret = dma_map_sg(&mdev->pdev->dev, sg, nents, dir);
  	if (ret <= 0)
  		return 0;
  
  	for_each_sg(sg, s, nents, i) {
  		da = mic_map(mdev, sg_dma_address(s) + s->offset, s->length);
  		if (!da)
  			goto err;
  		sg_dma_address(s) = da;
  	}
  	return nents;
  err:
  	for_each_sg(sg, s, i, j) {
  		mic_unmap(mdev, sg_dma_address(s), s->length);
  		sg_dma_address(s) = mic_to_dma_addr(mdev, sg_dma_address(s));
  	}
  	dma_unmap_sg(&mdev->pdev->dev, sg, nents, dir);
  	return 0;
  }
  
  static void __mic_dma_unmap_sg(struct device *dev,
  			       struct scatterlist *sg, int nents,
  			       enum dma_data_direction dir,
  			       struct dma_attrs *attrs)
  {
  	struct scif_hw_dev *scdev = dev_get_drvdata(dev);
  	struct mic_device *mdev = scdev_to_mdev(scdev);
  	struct scatterlist *s;
  	dma_addr_t da;
  	int i;
  
  	for_each_sg(sg, s, nents, i) {
  		da = mic_to_dma_addr(mdev, sg_dma_address(s));
  		mic_unmap(mdev, sg_dma_address(s), s->length);
  		sg_dma_address(s) = da;
  	}
  	dma_unmap_sg(&mdev->pdev->dev, sg, nents, dir);
  }
  
  static struct dma_map_ops __mic_dma_ops = {
  	.alloc = __mic_dma_alloc,
  	.free = __mic_dma_free,
  	.map_page = __mic_dma_map_page,
  	.unmap_page = __mic_dma_unmap_page,
  	.map_sg = __mic_dma_map_sg,
  	.unmap_sg = __mic_dma_unmap_sg,
  };
  
  static struct mic_irq *
  ___mic_request_irq(struct scif_hw_dev *scdev,
  		   irqreturn_t (*func)(int irq, void *data),
  				       const char *name,
  				       void *data, int db)
  {
  	struct mic_device *mdev = scdev_to_mdev(scdev);
  
  	return mic_request_threaded_irq(mdev, func, NULL, name, data,
  					db, MIC_INTR_DB);
  }
  
  static void
  ___mic_free_irq(struct scif_hw_dev *scdev,
  		struct mic_irq *cookie, void *data)
  {
  	struct mic_device *mdev = scdev_to_mdev(scdev);
  
  	return mic_free_irq(mdev, cookie, data);
  }
  
  static void ___mic_ack_interrupt(struct scif_hw_dev *scdev, int num)
  {
  	struct mic_device *mdev = scdev_to_mdev(scdev);
  
  	mdev->ops->intr_workarounds(mdev);
  }
  
  static int ___mic_next_db(struct scif_hw_dev *scdev)
  {
  	struct mic_device *mdev = scdev_to_mdev(scdev);
  
  	return mic_next_db(mdev);
  }
  
  static void ___mic_send_intr(struct scif_hw_dev *scdev, int db)
  {
  	struct mic_device *mdev = scdev_to_mdev(scdev);
  
  	mdev->ops->send_intr(mdev, db);
  }
  
  static void __iomem *___mic_ioremap(struct scif_hw_dev *scdev,
  				    phys_addr_t pa, size_t len)
  {
  	struct mic_device *mdev = scdev_to_mdev(scdev);
  
  	return mdev->aper.va + pa;
  }
  
  static void ___mic_iounmap(struct scif_hw_dev *scdev, void __iomem *va)
  {
  	/* nothing to do */
  }
  
  static struct scif_hw_ops scif_hw_ops = {
  	.request_irq = ___mic_request_irq,
  	.free_irq = ___mic_free_irq,
  	.ack_interrupt = ___mic_ack_interrupt,
  	.next_db = ___mic_next_db,
  	.send_intr = ___mic_send_intr,
  	.ioremap = ___mic_ioremap,
  	.iounmap = ___mic_iounmap,
  };
  
  static inline struct mic_device *mbdev_to_mdev(struct mbus_device *mbdev)
  {
  	return dev_get_drvdata(mbdev->dev.parent);
  }
  
  static dma_addr_t
  mic_dma_map_page(struct device *dev, struct page *page,
  		 unsigned long offset, size_t size, enum dma_data_direction dir,
  		 struct dma_attrs *attrs)
  {
  	void *va = phys_to_virt(page_to_phys(page)) + offset;
  	struct mic_device *mdev = dev_get_drvdata(dev->parent);
  
  	return mic_map_single(mdev, va, size);
  }
  
  static void
  mic_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
  		   size_t size, enum dma_data_direction dir,
  		   struct dma_attrs *attrs)
  {
  	struct mic_device *mdev = dev_get_drvdata(dev->parent);
  	mic_unmap_single(mdev, dma_addr, size);
  }
  
  static struct dma_map_ops mic_dma_ops = {
  	.map_page = mic_dma_map_page,
  	.unmap_page = mic_dma_unmap_page,
  };
  
  static struct mic_irq *
  _mic_request_threaded_irq(struct mbus_device *mbdev,
  			  irq_handler_t handler, irq_handler_t thread_fn,
  			  const char *name, void *data, int intr_src)
  {
  	return mic_request_threaded_irq(mbdev_to_mdev(mbdev), handler,
  					thread_fn, name, data,
  					intr_src, MIC_INTR_DMA);
  }
  
  static void _mic_free_irq(struct mbus_device *mbdev,
  			  struct mic_irq *cookie, void *data)
  {
  	return mic_free_irq(mbdev_to_mdev(mbdev), cookie, data);
  }
  
  static void _mic_ack_interrupt(struct mbus_device *mbdev, int num)
  {
  	struct mic_device *mdev = mbdev_to_mdev(mbdev);
  	mdev->ops->intr_workarounds(mdev);
  }
  
  static struct mbus_hw_ops mbus_hw_ops = {
  	.request_threaded_irq = _mic_request_threaded_irq,
  	.free_irq = _mic_free_irq,
  	.ack_interrupt = _mic_ack_interrupt,
  };
  
  /* Initialize the MIC bootparams */
  void mic_bootparam_init(struct mic_device *mdev)
  {
  	struct mic_bootparam *bootparam = mdev->dp;
  
  	bootparam->magic = cpu_to_le32(MIC_MAGIC);
  	bootparam->h2c_config_db = -1;
  	bootparam->node_id = mdev->id + 1;
  	bootparam->scif_host_dma_addr = 0x0;
  	bootparam->scif_card_dma_addr = 0x0;
  	bootparam->c2h_scif_db = -1;
  	bootparam->h2c_scif_db = -1;
  }
  
  static inline struct mic_device *cosmdev_to_mdev(struct cosm_device *cdev)
  {
  	return dev_get_drvdata(cdev->dev.parent);
  }
  
  static void _mic_reset(struct cosm_device *cdev)
  {
  	struct mic_device *mdev = cosmdev_to_mdev(cdev);
  
  	mdev->ops->reset_fw_ready(mdev);
  	mdev->ops->reset(mdev);
  }
  
  static bool _mic_ready(struct cosm_device *cdev)
  {
  	struct mic_device *mdev = cosmdev_to_mdev(cdev);
  
  	return mdev->ops->is_fw_ready(mdev);
  }
  
  /**
   * mic_request_dma_chans - Request DMA channels
   * @mdev: pointer to mic_device instance
   *
   * returns number of DMA channels acquired
   */
  static int mic_request_dma_chans(struct mic_device *mdev)
  {
  	dma_cap_mask_t mask;
  	struct dma_chan *chan;
  
  	request_module("mic_x100_dma");
  	dma_cap_zero(mask);
  	dma_cap_set(DMA_MEMCPY, mask);
  
  	do {
  		chan = dma_request_channel(mask, mdev->ops->dma_filter,
  					   &mdev->pdev->dev);
  		if (chan) {
  			mdev->dma_ch[mdev->num_dma_ch++] = chan;
  			if (mdev->num_dma_ch >= MIC_MAX_DMA_CHAN)
  				break;
  		}
  	} while (chan);
  	dev_info(&mdev->pdev->dev, "DMA channels # %d
  ", mdev->num_dma_ch);
  	return mdev->num_dma_ch;
  }
  
  /**
   * mic_free_dma_chans - release DMA channels
   * @mdev: pointer to mic_device instance
   *
   * returns none
   */
  static void mic_free_dma_chans(struct mic_device *mdev)
  {
  	int i = 0;
  
  	for (i = 0; i < mdev->num_dma_ch; i++) {
  		dma_release_channel(mdev->dma_ch[i]);
  		mdev->dma_ch[i] = NULL;
  	}
  	mdev->num_dma_ch = 0;
  }
  
  /**
   * _mic_start - Start the MIC.
   * @cdev: pointer to cosm_device instance
   * @id: MIC device id/index provided by COSM used in other drivers like SCIF
   *
   * This function prepares an MIC for boot and initiates boot.
   * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
   *
   * For all cosm_hw_ops the caller holds a mutex to ensure serialization.
   */
  static int _mic_start(struct cosm_device *cdev, int id)
  {
  	struct mic_device *mdev = cosmdev_to_mdev(cdev);
  	int rc;
  
  	mic_bootparam_init(mdev);
  	mdev->dma_mbdev = mbus_register_device(&mdev->pdev->dev,
  					       MBUS_DEV_DMA_HOST, &mic_dma_ops,
  					       &mbus_hw_ops, id, mdev->mmio.va);
  	if (IS_ERR(mdev->dma_mbdev)) {
  		rc = PTR_ERR(mdev->dma_mbdev);
  		goto unlock_ret;
  	}
  	if (!mic_request_dma_chans(mdev)) {
  		rc = -ENODEV;
  		goto dma_remove;
  	}
  	mdev->scdev = scif_register_device(&mdev->pdev->dev, MIC_SCIF_DEV,
  					   &__mic_dma_ops, &scif_hw_ops,
  					   id + 1, 0, &mdev->mmio,
  					   &mdev->aper, mdev->dp, NULL,
  					   mdev->dma_ch, mdev->num_dma_ch,
  					   true);
  	if (IS_ERR(mdev->scdev)) {
  		rc = PTR_ERR(mdev->scdev);
  		goto dma_free;
  	}
  
  	rc = mdev->ops->load_mic_fw(mdev, NULL);
  	if (rc)
  		goto scif_remove;
  	mic_smpt_restore(mdev);
  	mic_intr_restore(mdev);
  	mdev->intr_ops->enable_interrupts(mdev);
  	mdev->ops->write_spad(mdev, MIC_DPLO_SPAD, mdev->dp_dma_addr);
  	mdev->ops->write_spad(mdev, MIC_DPHI_SPAD, mdev->dp_dma_addr >> 32);
  	mdev->ops->send_firmware_intr(mdev);
  	goto unlock_ret;
  scif_remove:
  	scif_unregister_device(mdev->scdev);
  dma_free:
  	mic_free_dma_chans(mdev);
  dma_remove:
  	mbus_unregister_device(mdev->dma_mbdev);
  unlock_ret:
  	return rc;
  }
  
  /**
   * _mic_stop - Prepare the MIC for reset and trigger reset.
   * @cdev: pointer to cosm_device instance
   * @force: force a MIC to reset even if it is already offline.
   *
   * RETURNS: None.
   */
  static void _mic_stop(struct cosm_device *cdev, bool force)
  {
  	struct mic_device *mdev = cosmdev_to_mdev(cdev);
  
  	/*
  	 * Since SCIF handles card shutdown and reset (using COSM), it will
  	 * will be the first to be registered and the last to be
  	 * unregistered.
  	 */
  	mic_virtio_reset_devices(mdev);
  	scif_unregister_device(mdev->scdev);
  	mic_free_dma_chans(mdev);
  	mbus_unregister_device(mdev->dma_mbdev);
  	mic_bootparam_init(mdev);
  }
  
  static ssize_t _mic_family(struct cosm_device *cdev, char *buf)
  {
  	struct mic_device *mdev = cosmdev_to_mdev(cdev);
  	static const char *family[MIC_FAMILY_LAST] = { "x100", "Unknown" };
  
  	return scnprintf(buf, PAGE_SIZE, "%s
  ", family[mdev->family]);
  }
  
  static ssize_t _mic_stepping(struct cosm_device *cdev, char *buf)
  {
  	struct mic_device *mdev = cosmdev_to_mdev(cdev);
  	const char *string = "??";
  
  	switch (mdev->stepping) {
  	case MIC_A0_STEP:
  		string = "A0";
  		break;
  	case MIC_B0_STEP:
  		string = "B0";
  		break;
  	case MIC_B1_STEP:
  		string = "B1";
  		break;
  	case MIC_C0_STEP:
  		string = "C0";
  		break;
  	default:
  		break;
  	}
  	return scnprintf(buf, PAGE_SIZE, "%s
  ", string);
  }
  
  static struct mic_mw *_mic_aper(struct cosm_device *cdev)
  {
  	struct mic_device *mdev = cosmdev_to_mdev(cdev);
  
  	return &mdev->aper;
  }
  
  struct cosm_hw_ops cosm_hw_ops = {
  	.reset = _mic_reset,
  	.force_reset = _mic_reset,
  	.post_reset = NULL,
  	.ready = _mic_ready,
  	.start = _mic_start,
  	.stop = _mic_stop,
  	.family = _mic_family,
  	.stepping = _mic_stepping,
  	.aper = _mic_aper,
  };