linux/drivers/staging/greybus/arche-platform.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Arche Platform driver to enable Unipro link.
 *
 * Copyright 2014-2015 Google Inc.
 * Copyright 2014-2015 Linaro Ltd.
 */

#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/of_platform.h>
#include <linux/pinctrl/consumer.h>
#include <linux/platform_device.h>
#include <linux/pm.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/suspend.h>
#include <linux/time.h>
#include <linux/greybus.h>
#include <linux/of.h>
#include "arche_platform.h"

#if IS_ENABLED(CONFIG_USB_HSIC_USB3613)
#include <linux/usb/usb3613.h>
#else
static inline int usb3613_hub_mode_ctrl(bool unused)
{ … }
#endif

#define WD_COLDBOOT_PULSE_WIDTH_MS …

enum svc_wakedetect_state { … };

struct arche_platform_drvdata { … };

/* Requires calling context to hold arche_pdata->platform_state_mutex */
static void arche_platform_set_state(struct arche_platform_drvdata *arche_pdata,
				     enum arche_platform_state state)
{ … }

/* Requires arche_pdata->wake_lock is held by calling context */
static void arche_platform_set_wake_detect_state(struct arche_platform_drvdata *arche_pdata,
						 enum svc_wakedetect_state state)
{ … }

static inline void svc_reset_onoff(struct gpio_desc *gpio, bool onoff)
{ … }

static int apb_cold_boot(struct device *dev, void *data)
{ … }

static int apb_poweroff(struct device *dev, void *data)
{ … }

static void arche_platform_wd_irq_en(struct arche_platform_drvdata *arche_pdata)
{ … }

static irqreturn_t arche_platform_wd_irq_thread(int irq, void *devid)
{ … }

static irqreturn_t arche_platform_wd_irq(int irq, void *devid)
{ … }

/*
 * Requires arche_pdata->platform_state_mutex to be held
 */
static int
arche_platform_coldboot_seq(struct arche_platform_drvdata *arche_pdata)
{ … }

/*
 * Requires arche_pdata->platform_state_mutex to be held
 */
static int
arche_platform_fw_flashing_seq(struct arche_platform_drvdata *arche_pdata)
{ … }

/*
 * Requires arche_pdata->platform_state_mutex to be held
 */
static void
arche_platform_poweroff_seq(struct arche_platform_drvdata *arche_pdata)
{ … }

static ssize_t state_store(struct device *dev,
			   struct device_attribute *attr,
			   const char *buf, size_t count)
{ … }

static ssize_t state_show(struct device *dev,
			  struct device_attribute *attr, char *buf)
{ … }

static DEVICE_ATTR_RW(state);

static int arche_platform_pm_notifier(struct notifier_block *notifier,
				      unsigned long pm_event, void *unused)
{ … }

static int arche_platform_probe(struct platform_device *pdev)
{ … }

static int arche_remove_child(struct device *dev, void *unused)
{ … }

static void arche_platform_remove(struct platform_device *pdev)
{ … }

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

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

static void arche_platform_shutdown(struct platform_device *pdev)
{ … }

static SIMPLE_DEV_PM_OPS(arche_platform_pm_ops,
			arche_platform_suspend,
			arche_platform_resume);

static const struct of_device_id arche_platform_of_match[] = …;
MODULE_DEVICE_TABLE(of, arche_platform_of_match);

static struct platform_driver arche_platform_device_driver = …;

static int __init arche_init(void)
{ … }
module_init(…) …;

static void __exit arche_exit(void)
{ … }
module_exit(arche_exit);

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