linux/drivers/staging/media/ipu3/ipu3.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2017 - 2018 Intel Corporation
 * Copyright 2017 Google LLC
 *
 * Based on Intel IPU4 driver.
 *
 */

#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/pm_runtime.h>

#include "ipu3.h"
#include "ipu3-css-fw.h"
#include "ipu3-dmamap.h"
#include "ipu3-mmu.h"

#define IMGU_PCI_ID …
#define IMGU_PCI_BAR …
#define IMGU_DMA_MASK …
#define IMGU_MAX_QUEUE_DEPTH …

/*
 * pre-allocated buffer size for IMGU dummy buffers. Those
 * values should be tuned to big enough to avoid buffer
 * re-allocation when streaming to lower streaming latency.
 */
#define CSS_QUEUE_IN_BUF_SIZE …
#define CSS_QUEUE_PARAMS_BUF_SIZE …
#define CSS_QUEUE_OUT_BUF_SIZE …
#define CSS_QUEUE_VF_BUF_SIZE …
#define CSS_QUEUE_STAT_3A_BUF_SIZE …

static const size_t css_queue_buf_size_map[IPU3_CSS_QUEUES] = …;

static const struct imgu_node_mapping imgu_node_map[IMGU_NODE_NUM] = …;

unsigned int imgu_node_to_queue(unsigned int node)
{ … }

unsigned int imgu_map_node(struct imgu_device *imgu, unsigned int css_queue)
{ … }

/**************** Dummy buffers ****************/

static void imgu_dummybufs_cleanup(struct imgu_device *imgu, unsigned int pipe)
{ … }

static int imgu_dummybufs_preallocate(struct imgu_device *imgu,
				      unsigned int pipe)
{ … }

static int imgu_dummybufs_init(struct imgu_device *imgu, unsigned int pipe)
{ … }

/* May be called from atomic context */
static struct imgu_css_buffer *imgu_dummybufs_get(struct imgu_device *imgu,
						   int queue, unsigned int pipe)
{ … }

/* Check if given buffer is a dummy buffer */
static bool imgu_dummybufs_check(struct imgu_device *imgu,
				 struct imgu_css_buffer *buf,
				 unsigned int pipe)
{ … }

static void imgu_buffer_done(struct imgu_device *imgu, struct vb2_buffer *vb,
			     enum vb2_buffer_state state)
{ … }

static struct imgu_css_buffer *imgu_queue_getbuf(struct imgu_device *imgu,
						 unsigned int node,
						 unsigned int pipe)
{ … }

/*
 * Queue as many buffers to CSS as possible. If all buffers don't fit into
 * CSS buffer queues, they remain unqueued and will be queued later.
 */
int imgu_queue_buffers(struct imgu_device *imgu, bool initial, unsigned int pipe)
{ … }

static int imgu_powerup(struct imgu_device *imgu)
{ … }

static void imgu_powerdown(struct imgu_device *imgu)
{ … }

int imgu_s_stream(struct imgu_device *imgu, int enable)
{ … }

static void imgu_video_nodes_exit(struct imgu_device *imgu)
{ … }

static int imgu_video_nodes_init(struct imgu_device *imgu)
{ … }

/**************** PCI interface ****************/

static irqreturn_t imgu_isr_threaded(int irq, void *imgu_ptr)
{ … }

static irqreturn_t imgu_isr(int irq, void *imgu_ptr)
{ … }

static int imgu_pci_config_setup(struct pci_dev *dev)
{ … }

static int imgu_pci_probe(struct pci_dev *pci_dev,
			  const struct pci_device_id *id)
{ … }

static void imgu_pci_remove(struct pci_dev *pci_dev)
{ … }

static int __maybe_unused imgu_suspend(struct device *dev)
{ … }

static int __maybe_unused imgu_resume(struct device *dev)
{ … }

/*
 * PCI rpm framework checks the existence of driver rpm callbacks.
 * Place a dummy callback here to avoid rpm going into error state.
 */
static __maybe_unused int imgu_rpm_dummy_cb(struct device *dev)
{ … }

static const struct dev_pm_ops imgu_pm_ops = …;

static const struct pci_device_id imgu_pci_tbl[] = …;

MODULE_DEVICE_TABLE(pci, imgu_pci_tbl);

static struct pci_driver imgu_pci_driver = …;

module_pci_driver(…) …;

MODULE_AUTHOR(…) …;
MODULE_AUTHOR(…) …;
MODULE_AUTHOR(…) …;
MODULE_AUTHOR(…) …;
MODULE_AUTHOR(…) …;
MODULE_LICENSE(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_FIRMWARE(…);
MODULE_FIRMWARE(…);
MODULE_FIRMWARE(…);