| /* |
| * 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/mic_common.h> |
| #include <linux/mic_bus.h> |
| #include "../common/mic_dev.h" |
| #include "mic_device.h" |
| #include "mic_smpt.h" |
| #include "mic_virtio.h" |
| |
| 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, |
| }; |
| |
| /** |
| * mic_reset - Reset the MIC device. |
| * @mdev: pointer to mic_device instance |
| */ |
| static void mic_reset(struct mic_device *mdev) |
| { |
| int i; |
| |
| #define MIC_RESET_TO (45) |
| |
| reinit_completion(&mdev->reset_wait); |
| mdev->ops->reset_fw_ready(mdev); |
| mdev->ops->reset(mdev); |
| |
| for (i = 0; i < MIC_RESET_TO; i++) { |
| if (mdev->ops->is_fw_ready(mdev)) |
| goto done; |
| /* |
| * Resets typically take 10s of seconds to complete. |
| * Since an MMIO read is required to check if the |
| * firmware is ready or not, a 1 second delay works nicely. |
| */ |
| msleep(1000); |
| } |
| mic_set_state(mdev, MIC_RESET_FAILED); |
| done: |
| complete_all(&mdev->reset_wait); |
| } |
| |
| /* 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->c2h_shutdown_db = mdev->shutdown_db; |
| bootparam->h2c_shutdown_db = -1; |
| bootparam->h2c_config_db = -1; |
| bootparam->shutdown_status = 0; |
| bootparam->shutdown_card = 0; |
| } |
| |
| /** |
| * mic_start - Start the MIC. |
| * @mdev: pointer to mic_device instance |
| * @buf: buffer containing boot string including firmware/ramdisk path. |
| * |
| * This function prepares an MIC for boot and initiates boot. |
| * RETURNS: An appropriate -ERRNO error value on error, or zero for success. |
| */ |
| int mic_start(struct mic_device *mdev, const char *buf) |
| { |
| int rc; |
| mutex_lock(&mdev->mic_mutex); |
| retry: |
| if (MIC_OFFLINE != mdev->state) { |
| rc = -EINVAL; |
| goto unlock_ret; |
| } |
| if (!mdev->ops->is_fw_ready(mdev)) { |
| mic_reset(mdev); |
| /* |
| * The state will either be MIC_OFFLINE if the reset succeeded |
| * or MIC_RESET_FAILED if the firmware reset failed. |
| */ |
| goto retry; |
| } |
| mdev->dma_mbdev = mbus_register_device(mdev->sdev->parent, |
| MBUS_DEV_DMA_HOST, &mic_dma_ops, |
| &mbus_hw_ops, mdev->mmio.va); |
| if (IS_ERR(mdev->dma_mbdev)) { |
| rc = PTR_ERR(mdev->dma_mbdev); |
| goto unlock_ret; |
| } |
| mdev->dma_ch = mic_request_dma_chan(mdev); |
| if (!mdev->dma_ch) { |
| rc = -ENXIO; |
| goto dma_remove; |
| } |
| rc = mdev->ops->load_mic_fw(mdev, buf); |
| if (rc) |
| goto dma_release; |
| 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); |
| mic_set_state(mdev, MIC_ONLINE); |
| goto unlock_ret; |
| dma_release: |
| dma_release_channel(mdev->dma_ch); |
| dma_remove: |
| mbus_unregister_device(mdev->dma_mbdev); |
| unlock_ret: |
| mutex_unlock(&mdev->mic_mutex); |
| return rc; |
| } |
| |
| /** |
| * mic_stop - Prepare the MIC for reset and trigger reset. |
| * @mdev: pointer to mic_device instance |
| * @force: force a MIC to reset even if it is already offline. |
| * |
| * RETURNS: None. |
| */ |
| void mic_stop(struct mic_device *mdev, bool force) |
| { |
| mutex_lock(&mdev->mic_mutex); |
| if (MIC_OFFLINE != mdev->state || force) { |
| mic_virtio_reset_devices(mdev); |
| if (mdev->dma_ch) { |
| dma_release_channel(mdev->dma_ch); |
| mdev->dma_ch = NULL; |
| } |
| mbus_unregister_device(mdev->dma_mbdev); |
| mic_bootparam_init(mdev); |
| mic_reset(mdev); |
| if (MIC_RESET_FAILED == mdev->state) |
| goto unlock; |
| mic_set_shutdown_status(mdev, MIC_NOP); |
| if (MIC_SUSPENDED != mdev->state) |
| mic_set_state(mdev, MIC_OFFLINE); |
| } |
| unlock: |
| mutex_unlock(&mdev->mic_mutex); |
| } |
| |
| /** |
| * mic_shutdown - Initiate MIC shutdown. |
| * @mdev: pointer to mic_device instance |
| * |
| * RETURNS: None. |
| */ |
| void mic_shutdown(struct mic_device *mdev) |
| { |
| struct mic_bootparam *bootparam = mdev->dp; |
| s8 db = bootparam->h2c_shutdown_db; |
| |
| mutex_lock(&mdev->mic_mutex); |
| if (MIC_ONLINE == mdev->state && db != -1) { |
| bootparam->shutdown_card = 1; |
| mdev->ops->send_intr(mdev, db); |
| mic_set_state(mdev, MIC_SHUTTING_DOWN); |
| } |
| mutex_unlock(&mdev->mic_mutex); |
| } |
| |
| /** |
| * mic_shutdown_work - Handle shutdown interrupt from MIC. |
| * @work: The work structure. |
| * |
| * This work is scheduled whenever the host has received a shutdown |
| * interrupt from the MIC. |
| */ |
| void mic_shutdown_work(struct work_struct *work) |
| { |
| struct mic_device *mdev = container_of(work, struct mic_device, |
| shutdown_work); |
| struct mic_bootparam *bootparam = mdev->dp; |
| |
| mutex_lock(&mdev->mic_mutex); |
| mic_set_shutdown_status(mdev, bootparam->shutdown_status); |
| bootparam->shutdown_status = 0; |
| |
| /* |
| * if state is MIC_SUSPENDED, OSPM suspend is in progress. We do not |
| * change the state here so as to prevent users from booting the card |
| * during and after the suspend operation. |
| */ |
| if (MIC_SHUTTING_DOWN != mdev->state && |
| MIC_SUSPENDED != mdev->state) |
| mic_set_state(mdev, MIC_SHUTTING_DOWN); |
| mutex_unlock(&mdev->mic_mutex); |
| } |
| |
| /** |
| * mic_reset_trigger_work - Trigger MIC reset. |
| * @work: The work structure. |
| * |
| * This work is scheduled whenever the host wants to reset the MIC. |
| */ |
| void mic_reset_trigger_work(struct work_struct *work) |
| { |
| struct mic_device *mdev = container_of(work, struct mic_device, |
| reset_trigger_work); |
| |
| mic_stop(mdev, false); |
| } |
| |
| /** |
| * mic_complete_resume - Complete MIC Resume after an OSPM suspend/hibernate |
| * event. |
| * @mdev: pointer to mic_device instance |
| * |
| * RETURNS: None. |
| */ |
| void mic_complete_resume(struct mic_device *mdev) |
| { |
| if (mdev->state != MIC_SUSPENDED) { |
| dev_warn(mdev->sdev->parent, "state %d should be %d\n", |
| mdev->state, MIC_SUSPENDED); |
| return; |
| } |
| |
| /* Make sure firmware is ready */ |
| if (!mdev->ops->is_fw_ready(mdev)) |
| mic_stop(mdev, true); |
| |
| mutex_lock(&mdev->mic_mutex); |
| mic_set_state(mdev, MIC_OFFLINE); |
| mutex_unlock(&mdev->mic_mutex); |
| } |
| |
| /** |
| * mic_prepare_suspend - Handle suspend notification for the MIC device. |
| * @mdev: pointer to mic_device instance |
| * |
| * RETURNS: None. |
| */ |
| void mic_prepare_suspend(struct mic_device *mdev) |
| { |
| int rc; |
| |
| #define MIC_SUSPEND_TIMEOUT (60 * HZ) |
| |
| mutex_lock(&mdev->mic_mutex); |
| switch (mdev->state) { |
| case MIC_OFFLINE: |
| /* |
| * Card is already offline. Set state to MIC_SUSPENDED |
| * to prevent users from booting the card. |
| */ |
| mic_set_state(mdev, MIC_SUSPENDED); |
| mutex_unlock(&mdev->mic_mutex); |
| break; |
| case MIC_ONLINE: |
| /* |
| * Card is online. Set state to MIC_SUSPENDING and notify |
| * MIC user space daemon which will issue card |
| * shutdown and reset. |
| */ |
| mic_set_state(mdev, MIC_SUSPENDING); |
| mutex_unlock(&mdev->mic_mutex); |
| rc = wait_for_completion_timeout(&mdev->reset_wait, |
| MIC_SUSPEND_TIMEOUT); |
| /* Force reset the card if the shutdown completion timed out */ |
| if (!rc) { |
| mutex_lock(&mdev->mic_mutex); |
| mic_set_state(mdev, MIC_SUSPENDED); |
| mutex_unlock(&mdev->mic_mutex); |
| mic_stop(mdev, true); |
| } |
| break; |
| case MIC_SHUTTING_DOWN: |
| /* |
| * Card is shutting down. Set state to MIC_SUSPENDED |
| * to prevent further boot of the card. |
| */ |
| mic_set_state(mdev, MIC_SUSPENDED); |
| mutex_unlock(&mdev->mic_mutex); |
| rc = wait_for_completion_timeout(&mdev->reset_wait, |
| MIC_SUSPEND_TIMEOUT); |
| /* Force reset the card if the shutdown completion timed out */ |
| if (!rc) |
| mic_stop(mdev, true); |
| break; |
| default: |
| mutex_unlock(&mdev->mic_mutex); |
| break; |
| } |
| } |
| |
| /** |
| * mic_suspend - Initiate MIC suspend. Suspend merely issues card shutdown. |
| * @mdev: pointer to mic_device instance |
| * |
| * RETURNS: None. |
| */ |
| void mic_suspend(struct mic_device *mdev) |
| { |
| struct mic_bootparam *bootparam = mdev->dp; |
| s8 db = bootparam->h2c_shutdown_db; |
| |
| mutex_lock(&mdev->mic_mutex); |
| if (MIC_SUSPENDING == mdev->state && db != -1) { |
| bootparam->shutdown_card = 1; |
| mdev->ops->send_intr(mdev, db); |
| mic_set_state(mdev, MIC_SUSPENDED); |
| } |
| mutex_unlock(&mdev->mic_mutex); |
| } |