linux/drivers/bcma/main.c

/*
 * Broadcom specific AMBA
 * Bus subsystem
 *
 * Licensed under the GNU/GPL. See COPYING for details.
 */

#include "bcma_private.h"
#include <linux/module.h>
#include <linux/mmc/sdio_func.h>
#include <linux/platform_device.h>
#include <linux/pci.h>
#include <linux/bcma/bcma.h>
#include <linux/slab.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_device.h>
#include <linux/of_platform.h>

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

/* contains the number the next bus should get. */
static unsigned int bcma_bus_next_num;

/* bcma_buses_mutex locks the bcma_bus_next_num */
static DEFINE_MUTEX(bcma_buses_mutex);

static int bcma_bus_match(struct device *dev, const struct device_driver *drv);
static int bcma_device_probe(struct device *dev);
static void bcma_device_remove(struct device *dev);
static int bcma_device_uevent(const struct device *dev, struct kobj_uevent_env *env);

static ssize_t manuf_show(struct device *dev, struct device_attribute *attr, char *buf)
{ … }
static DEVICE_ATTR_RO(manuf);

static ssize_t id_show(struct device *dev, struct device_attribute *attr, char *buf)
{ … }
static DEVICE_ATTR_RO(id);

static ssize_t rev_show(struct device *dev, struct device_attribute *attr, char *buf)
{ … }
static DEVICE_ATTR_RO(rev);

static ssize_t class_show(struct device *dev, struct device_attribute *attr, char *buf)
{ … }
static DEVICE_ATTR_RO(class);

static struct attribute *bcma_device_attrs[] = …;
ATTRIBUTE_GROUPS(…);

static const struct bus_type bcma_bus_type = …;

static u16 bcma_cc_core_id(struct bcma_bus *bus)
{ … }

struct bcma_device *bcma_find_core_unit(struct bcma_bus *bus, u16 coreid,
					u8 unit)
{ … }
EXPORT_SYMBOL_GPL(…);

bool bcma_wait_value(struct bcma_device *core, u16 reg, u32 mask, u32 value,
		     int timeout)
{ … }

static void bcma_release_core_dev(struct device *dev)
{ … }

static bool bcma_is_core_needed_early(u16 core_id)
{ … }

static struct device_node *bcma_of_find_child_device(struct device *parent,
						     struct bcma_device *core)
{ … }

static int bcma_of_irq_parse(struct device *parent,
			     struct bcma_device *core,
			     struct of_phandle_args *out_irq, int num)
{ … }

static unsigned int bcma_of_get_irq(struct device *parent,
				    struct bcma_device *core, int num)
{ … }

static void bcma_of_fill_device(struct device *parent,
				struct bcma_device *core)
{ … }

unsigned int bcma_core_irq(struct bcma_device *core, int num)
{ … }
EXPORT_SYMBOL(…);

void bcma_prepare_core(struct bcma_bus *bus, struct bcma_device *core)
{ … }

void bcma_init_bus(struct bcma_bus *bus)
{ … }

static void bcma_register_core(struct bcma_bus *bus, struct bcma_device *core)
{ … }

static int bcma_register_devices(struct bcma_bus *bus)
{ … }

void bcma_unregister_cores(struct bcma_bus *bus)
{ … }

int bcma_bus_register(struct bcma_bus *bus)
{ … }

void bcma_bus_unregister(struct bcma_bus *bus)
{ … }

/*
 * This is a special version of bus registration function designed for SoCs.
 * It scans bus and performs basic initialization of main cores only.
 * Please note it requires memory allocation, however it won't try to sleep.
 */
int __init bcma_bus_early_register(struct bcma_bus *bus)
{ … }

#ifdef CONFIG_PM
int bcma_bus_suspend(struct bcma_bus *bus)
{ … }

int bcma_bus_resume(struct bcma_bus *bus)
{ … }
#endif

int __bcma_driver_register(struct bcma_driver *drv, struct module *owner)
{ … }
EXPORT_SYMBOL_GPL(…);

void bcma_driver_unregister(struct bcma_driver *drv)
{ … }
EXPORT_SYMBOL_GPL(…);

static int bcma_bus_match(struct device *dev, const struct device_driver *drv)
{ … }

static int bcma_device_probe(struct device *dev)
{ … }

static void bcma_device_remove(struct device *dev)
{ … }

static int bcma_device_uevent(const struct device *dev, struct kobj_uevent_env *env)
{ … }

static unsigned int bcma_bus_registered;

/*
 * If built-in, bus has to be registered early, before any driver calls
 * bcma_driver_register.
 * Otherwise registering driver would trigger BUG in driver_register.
 */
static int __init bcma_init_bus_register(void)
{ … }
#ifndef MODULE
fs_initcall(bcma_init_bus_register);
#endif

/* Main initialization has to be done with SPI/mtd/NAND/SPROM available */
static int __init bcma_modinit(void)
{ … }
module_init(…) …;

static void __exit bcma_modexit(void)
{ … }
module_exit(…)