/* Manually detach a device from its associated driver. */
static ssize_t driver_unbind(struct device_driver *drv,
const char *buf, size_t count)
{
struct bus_type *bus = bus_get(drv->bus);
struct device *dev;
int err = -ENODEV;
dev = bus_find_device_by_name(bus, NULL, buf);
if (dev && dev->driver == drv) {
if (dev->parent) /* Needed for USB */
device_lock(dev->parent);
device_release_driver(dev);
if (dev->parent)
device_unlock(dev->parent);
err = count;
}
put_device(dev);
bus_put(bus);
return err;
}
static struct platform_device *hsi_get_hsi_platform_device(void)
{
struct device *dev;
struct platform_device *pdev;
/* HSI_TODO: handle platform device id (or port) (0/1) */
dev = bus_find_device_by_name(&platform_bus_type, NULL,
OMAP_HSI_PLATFORM_DEVICE_NAME);
if (!dev) {
pr_debug("Could not find platform device %s\n",
OMAP_HSI_PLATFORM_DEVICE_NAME);
return 0;
}
if (!dev->driver) {
/* Could not find driver for platform device. */
return 0;
}
pdev = to_platform_device(dev);
return pdev;
}
/*
* Manually attach a device to a driver.
* Note: the driver must want to bind to the device,
* it is not possible to override the driver's id table.
*/
static ssize_t bind_store(struct device_driver *drv, const char *buf,
size_t count)
{
struct bus_type *bus = bus_get(drv->bus);
struct device *dev;
int err = -ENODEV;
dev = bus_find_device_by_name(bus, NULL, buf);
if (dev && dev->driver == NULL && driver_match_device(drv, dev)) {
err = device_driver_attach(drv, dev);
if (err > 0) {
/* success */
err = count;
} else if (err == 0) {
/* driver didn't accept device */
err = -ENODEV;
}
}
put_device(dev);
bus_put(bus);
return err;
}
/*====================================================================
FUNCTION find_spi_device
DESCRIPTION
DEPENDENCIES
RETURN VALUE
SIDE EFFECTS
======================================================================*/
static struct spi_device* find_spi_device(int bus_num)
{
struct spi_master *spi_master;
struct spi_device *spi_device;
struct device *pdev;
char buff[64];
spi_master = spi_busnum_to_master(bus_num);
if (!spi_master) {
TDMB_MSG_SPI("[%s] spi_busnum_to_master(%d) returned NULL\n", __func__, bus_num);
return NULL;
}
spi_device = spi_alloc_device(spi_master);
if (!spi_device) {
put_device(&spi_master->dev);
TDMB_MSG_SPI("[%s] spi_alloc_device() failed\n", __func__);
return NULL;
}
/* specify a chip select line */
spi_device->chip_select = 0;
snprintf(buff, sizeof(buff), "%s.%u",
dev_name(&spi_device->master->dev),
spi_device->chip_select);
pdev = bus_find_device_by_name(spi_device->dev.bus, NULL, buff);
//if (pdev) {
// TCDBG("spi_device :0x%X\n", (unsigned int)spi_device);
//}
put_device(&spi_master->dev);
return spi_device;
}
static int cc2520_spi_add_to_bus(void)
{
struct spi_master *spi_master;
struct spi_device *spi_device;
struct device *pdev;
char buff[64];
int status = 0;
spi_master = spi_busnum_to_master(SPI_BUS);
if (!spi_master) {
printk(KERN_ALERT "[cc2520] - spi_busnum_to_master(%d) returned NULL\n",
SPI_BUS);
printk(KERN_ALERT "[cc2520] - Missing modprobe spi-bcm2708?\n");
return -1;
}
spi_device = spi_alloc_device(spi_master);
if (!spi_device) {
put_device(&spi_master->dev);
printk(KERN_ALERT "[cc2520] - spi_alloc_device() failed\n");
return -1;
}
spi_device->chip_select = SPI_BUS_CS0;
/* Check whether this SPI bus.cs is already claimed */
snprintf(buff, sizeof(buff), "%s.%u",
dev_name(&spi_device->master->dev),
spi_device->chip_select);
pdev = bus_find_device_by_name(spi_device->dev.bus, NULL, buff);
if (pdev) {
if (pdev->driver != NULL) {
printk(KERN_INFO
"[cc2520] - Driver [%s] already registered for %s. Nuking from orbit.\n",
pdev->driver->name, buff);
}
else {
printk(KERN_INFO
"[cc2520] - Previous driver registered with no loaded module. Nuking from orbit.\n");
}
device_unregister(pdev);
}
spi_device->max_speed_hz = SPI_BUS_SPEED;
spi_device->mode = SPI_MODE_0;
spi_device->bits_per_word = 8;
spi_device->irq = -1;
spi_device->controller_state = NULL;
spi_device->controller_data = NULL;
strlcpy(spi_device->modalias, cc2520_name, SPI_NAME_SIZE);
status = spi_add_device(spi_device);
if (status < 0) {
spi_dev_put(spi_device);
printk(KERN_ALERT "[cc2520] - spi_add_device() failed: %d\n",
status);
}
put_device(&spi_master->dev);
return status;
}
void __init stx7108_configure_pci(struct stm_plat_pci_config *pci_conf)
{
struct sysconf_field *sc;
int i;
/* LLA clocks have these horrible names... */
pci_conf->clk_name = "CLKA_PCI";
/* REQ0 is actually wired to REQ3 to work around NAND problems */
pci_conf->req0_to_req3 = 1;
BUG_ON(pci_conf->req_gnt[3] != PCI_PIN_UNUSED);
/* Fill in the default values */
if (!pci_conf->ad_override_default) {
pci_conf->ad_threshold = 5;
pci_conf->ad_read_ahead = 1;
pci_conf->ad_chunks_in_msg = 0;
pci_conf->ad_pcks_in_chunk = 0;
pci_conf->ad_trigger_mode = 1;
pci_conf->ad_max_opcode = 5;
pci_conf->ad_posted = 1;
}
/* Copy over platform specific data to driver */
stx7108_pci_device.dev.platform_data = pci_conf;
#if defined(CONFIG_PM)
#warning TODO: PCI Power Management
#endif
/* Claim and power up the PCI cell */
sc = sysconf_claim(SYS_CFG_BANK2, 30, 2, 2, "PCI_PWR_DWN_REQ");
sysconf_write(sc, 0); /* We will need to stash this somewhere
for power management. */
sc = sysconf_claim(SYS_STA_BANK2, 1, 2, 2, "PCI_PWR_DWN_GRANT");
while (sysconf_read(sc))
cpu_relax(); /* Loop until powered up */
/* Configure the REQ/GNT[1..2], muxed with PIOs */
for (i = 1; i <= 2; i++) {
switch (pci_conf->req_gnt[i]) {
case PCI_PIN_DEFAULT:
if (stm_pad_claim(&stx7108_pci_reqgnt_pad_config[i],
"PCI") == NULL) {
printk(KERN_ERR "Failed to claim REQ/GNT%d "
"pads!\n", i);
BUG();
}
break;
case PCI_PIN_UNUSED:
/* Unused is unused - nothing to do */
break;
default:
/* No alternative here... */
BUG();
break;
}
}
/* Configure INTA..D interrupts */
for (i = 0; i < 4; i++) {
switch (pci_conf->pci_irq[i]) {
case PCI_PIN_DEFAULT:
if (stm_pad_claim(&stx7108_pci_int_pad_config[i],
"PCI") == NULL) {
printk(KERN_ERR "Failed to claim INT%c pad!\n",
'A' + i);
BUG();
}
set_irq_type(ILC_IRQ(122 + i), IRQ_TYPE_LEVEL_LOW);
break;
case PCI_PIN_ALTERNATIVE:
/* There is no alternative here ;-) */
BUG();
break;
default:
/* Unused or interrupt number passed, nothing to do */
break;
}
}
/* Configure the SERR interrupt (if wired up) */
switch (pci_conf->serr_irq) {
case PCI_PIN_DEFAULT:
if (gpio_request(STX7108_PIO_PCI_SERR, "PCI_SERR#") == 0) {
gpio_direction_input(STX7108_PIO_PCI_SERR);
pci_conf->serr_irq = gpio_to_irq(STX7108_PIO_PCI_SERR);
set_irq_type(pci_conf->serr_irq, IRQ_TYPE_LEVEL_LOW);
} else {
printk(KERN_WARNING "%s(): Failed to claim PCI SERR# "
"PIO!\n", __func__);
pci_conf->serr_irq = PCI_PIN_UNUSED;
}
break;
case PCI_PIN_ALTERNATIVE:
/* No alternative here */
BUG();
pci_conf->serr_irq = PCI_PIN_UNUSED;
break;
}
if (pci_conf->serr_irq != PCI_PIN_UNUSED) {
struct resource *res =
platform_get_resource_byname(&stx7108_pci_device,
IORESOURCE_IRQ, "pci serr");
BUG_ON(!res);
res->start = pci_conf->serr_irq;
res->end = pci_conf->serr_irq;
}
/* LOCK is not claimed as is totally pointless, the SOCs do not
* support any form of coherency */
stx7108_pci_device.dev.parent =
bus_find_device_by_name(&platform_bus_type, NULL, "emi");
platform_device_register(&stx7108_pci_device);
}
int __init e1853_panel_init(void)
{
bool has_ebb = false;
int err;
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
struct resource *res;
struct platform_device *phost1x = NULL;
#endif
bool is_dt = of_have_populated_dt();
if (tegra_is_board(NULL, "61861", NULL, NULL, NULL)) {
has_ebb = true;
if (tegra_is_board(NULL, "61227", NULL, NULL, NULL)) {
e1853_config_CLAA101WB03_lcd();
e1853_touch_init();
}
}
e1853_carveouts[1].base = tegra_carveout_start;
e1853_carveouts[1].size = tegra_carveout_size;
tegra_disp1_device.dev.platform_data = &e1853_disp1_pdata;
tegra_disp2_device.dev.platform_data = &e1853_hdmi_pdata;
err = platform_add_devices(e1853_gfx_devices,
ARRAY_SIZE(e1853_gfx_devices));
#ifdef CONFIG_TEGRA_GRHOST
if (!is_dt)
phost1x = tegra3_register_host1x_devices();
else
phost1x = to_platform_device(bus_find_device_by_name(
&platform_bus_type, NULL, "host1x"));
if (!phost1x) {
pr_err("host1x devices registration failed\n");
return -EINVAL;
}
#endif
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = platform_get_resource_byname(&tegra_disp1_device,
IORESOURCE_MEM, "fbmem");
if (res) {
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
}
/*
* If the bootloader fb is valid, copy it to the fb, or else
* clear fb to avoid garbage on dispaly1.
*/
if (tegra_bootloader_fb_size)
__tegra_move_framebuffer(&e1853_nvmap_device,
tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
else
__tegra_clear_framebuffer(&e1853_nvmap_device,
tegra_fb_start, tegra_fb_size);
if (!err) {
tegra_disp1_device.dev.parent = &phost1x->dev;
err = platform_device_register(&tegra_disp1_device);
}
res = platform_get_resource_byname(&tegra_disp2_device,
IORESOURCE_MEM, "fbmem");
if (res) {
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
}
/*
* If the bootloader fb2 is valid, copy it to the fb2, or else
* clear fb2 to avoid garbage on dispaly2.
*/
if (tegra_bootloader_fb2_size)
__tegra_move_framebuffer(&e1853_nvmap_device,
tegra_fb2_start, tegra_bootloader_fb2_start,
min(tegra_fb2_size, tegra_bootloader_fb2_size));
else
__tegra_clear_framebuffer(&e1853_nvmap_device,
tegra_fb2_start, tegra_fb2_size);
if (!err) {
tegra_disp2_device.dev.parent = &phost1x->dev;
err = platform_device_register(&tegra_disp2_device);
}
#endif
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_NVAVP)
if (!err) {
nvavp_device.dev.parent = &phost1x->dev;
err = platform_device_register(&nvavp_device);
}
#endif
if (has_ebb) {
if (!err)
i2c_register_board_info(1, lvds_ser_info, 1);
}
return err;
}
static int snd_byt_rt5651_mc_probe(struct platform_device *pdev)
{
const char * const mic_name[] = { "dmic", "in1", "in2", "in12" };
struct byt_rt5651_private *priv;
struct snd_soc_acpi_mach *mach;
struct device *codec_dev;
const char *i2c_name = NULL;
const char *hp_swapped;
bool is_bytcr = false;
int ret_val = 0;
int dai_index = 0;
int i;
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
/* register the soc card */
byt_rt5651_card.dev = &pdev->dev;
mach = byt_rt5651_card.dev->platform_data;
snd_soc_card_set_drvdata(&byt_rt5651_card, priv);
/* fix index of codec dai */
for (i = 0; i < ARRAY_SIZE(byt_rt5651_dais); i++) {
if (!strcmp(byt_rt5651_dais[i].codec_name, "i2c-10EC5651:00")) {
dai_index = i;
break;
}
}
/* fixup codec name based on HID */
i2c_name = acpi_dev_get_first_match_name(mach->id, NULL, -1);
if (!i2c_name) {
dev_err(&pdev->dev, "Error cannot find '%s' dev\n", mach->id);
return -ENODEV;
}
snprintf(byt_rt5651_codec_name, sizeof(byt_rt5651_codec_name),
"%s%s", "i2c-", i2c_name);
byt_rt5651_dais[dai_index].codec_name = byt_rt5651_codec_name;
codec_dev = bus_find_device_by_name(&i2c_bus_type, NULL,
byt_rt5651_codec_name);
if (!codec_dev)
return -EPROBE_DEFER;
/*
* swap SSP0 if bytcr is detected
* (will be overridden if DMI quirk is detected)
*/
if (x86_match_cpu(baytrail_cpu_ids)) {
struct sst_platform_info *p_info = mach->pdata;
const struct sst_res_info *res_info = p_info->res_info;
if (res_info->acpi_ipc_irq_index == 0)
is_bytcr = true;
}
if (is_bytcr) {
/*
* Baytrail CR platforms may have CHAN package in BIOS, try
* to find relevant routing quirk based as done on Windows
* platforms. We have to read the information directly from the
* BIOS, at this stage the card is not created and the links
* with the codec driver/pdata are non-existent
*/
struct acpi_chan_package chan_package;
/* format specified: 2 64-bit integers */
struct acpi_buffer format = {sizeof("NN"), "NN"};
struct acpi_buffer state = {0, NULL};
struct snd_soc_acpi_package_context pkg_ctx;
bool pkg_found = false;
state.length = sizeof(chan_package);
state.pointer = &chan_package;
pkg_ctx.name = "CHAN";
pkg_ctx.length = 2;
pkg_ctx.format = &format;
pkg_ctx.state = &state;
pkg_ctx.data_valid = false;
pkg_found = snd_soc_acpi_find_package_from_hid(mach->id,
&pkg_ctx);
if (pkg_found) {
if (chan_package.aif_value == 1) {
dev_info(&pdev->dev, "BIOS Routing: AIF1 connected\n");
byt_rt5651_quirk |= BYT_RT5651_SSP0_AIF1;
} else if (chan_package.aif_value == 2) {
dev_info(&pdev->dev, "BIOS Routing: AIF2 connected\n");
byt_rt5651_quirk |= BYT_RT5651_SSP0_AIF2;
} else {
dev_info(&pdev->dev, "BIOS Routing isn't valid, ignored\n");
pkg_found = false;
}
}
if (!pkg_found) {
/* no BIOS indications, assume SSP0-AIF2 connection */
byt_rt5651_quirk |= BYT_RT5651_SSP0_AIF2;
}
}
/* check quirks before creating card */
dmi_check_system(byt_rt5651_quirk_table);
/* Must be called before register_card, also see declaration comment. */
ret_val = byt_rt5651_add_codec_device_props(codec_dev);
if (ret_val) {
put_device(codec_dev);
return ret_val;
}
/* Cherry Trail devices use an external amplifier enable gpio */
if (x86_match_cpu(cherrytrail_cpu_ids)) {
snd_byt_rt5651_mc_add_amp_en_gpio_mapping(codec_dev);
priv->ext_amp_gpio = devm_fwnode_get_index_gpiod_from_child(
&pdev->dev, "ext-amp-enable", 0,
codec_dev->fwnode,
GPIOD_OUT_LOW, "speaker-amp");
if (IS_ERR(priv->ext_amp_gpio)) {
ret_val = PTR_ERR(priv->ext_amp_gpio);
switch (ret_val) {
case -ENOENT:
priv->ext_amp_gpio = NULL;
break;
default:
dev_err(&pdev->dev, "Failed to get ext-amp-enable GPIO: %d\n",
ret_val);
/* fall through */
case -EPROBE_DEFER:
put_device(codec_dev);
return ret_val;
}
}
}
put_device(codec_dev);
log_quirks(&pdev->dev);
if ((byt_rt5651_quirk & BYT_RT5651_SSP2_AIF2) ||
(byt_rt5651_quirk & BYT_RT5651_SSP0_AIF2)) {
/* fixup codec aif name */
snprintf(byt_rt5651_codec_aif_name,
sizeof(byt_rt5651_codec_aif_name),
"%s", "rt5651-aif2");
byt_rt5651_dais[dai_index].codec_dai_name =
byt_rt5651_codec_aif_name;
}
if ((byt_rt5651_quirk & BYT_RT5651_SSP0_AIF1) ||
(byt_rt5651_quirk & BYT_RT5651_SSP0_AIF2)) {
/* fixup cpu dai name name */
snprintf(byt_rt5651_cpu_dai_name,
sizeof(byt_rt5651_cpu_dai_name),
"%s", "ssp0-port");
byt_rt5651_dais[dai_index].cpu_dai_name =
byt_rt5651_cpu_dai_name;
}
if (byt_rt5651_quirk & BYT_RT5651_MCLK_EN) {
priv->mclk = devm_clk_get(&pdev->dev, "pmc_plt_clk_3");
if (IS_ERR(priv->mclk)) {
ret_val = PTR_ERR(priv->mclk);
dev_err(&pdev->dev,
"Failed to get MCLK from pmc_plt_clk_3: %d\n",
ret_val);
/*
* Fall back to bit clock usage for -ENOENT (clock not
* available likely due to missing dependencies), bail
* for all other errors, including -EPROBE_DEFER
*/
if (ret_val != -ENOENT)
return ret_val;
byt_rt5651_quirk &= ~BYT_RT5651_MCLK_EN;
}
}
if (byt_rt5651_quirk & BYT_RT5651_HP_LR_SWAPPED)
hp_swapped = "-hp-swapped";
else
hp_swapped = "";
snprintf(byt_rt5651_long_name, sizeof(byt_rt5651_long_name),
"bytcr-rt5651-%s-spk-%s-mic%s",
(byt_rt5651_quirk & BYT_RT5651_MONO_SPEAKER) ?
"mono" : "stereo",
mic_name[BYT_RT5651_MAP(byt_rt5651_quirk)], hp_swapped);
byt_rt5651_card.long_name = byt_rt5651_long_name;
ret_val = devm_snd_soc_register_card(&pdev->dev, &byt_rt5651_card);
if (ret_val) {
dev_err(&pdev->dev, "devm_snd_soc_register_card failed %d\n",
ret_val);
return ret_val;
}
platform_set_drvdata(pdev, &byt_rt5651_card);
return ret_val;
}
static int __init add_pcd8544_device_to_bus(void)
{
struct spi_master *spi_master;
struct spi_device *spi_device;
struct device *pdev;
char buff[64];
int status = 0;
spi_master = spi_busnum_to_master(SPI_BUS);
if (!spi_master) {
printk(KERN_ALERT "spi_busnum_to_master(%d) returned NULL\n",
SPI_BUS);
printk(KERN_ALERT "Missing modprobe omap2_mcspi?\n");
return -1;
}
spi_device = spi_alloc_device(spi_master);
if (!spi_device) {
put_device(&spi_master->dev);
printk(KERN_ALERT "spi_alloc_device() failed\n");
return -1;
}
spi_device->chip_select = SPI_BUS_CS;
/* Check whether this SPI bus.cs is already claimed */
snprintf(buff, sizeof(buff), "%s.%u",
dev_name(&spi_device->master->dev),
spi_device->chip_select);
pdev = bus_find_device_by_name(spi_device->dev.bus, NULL, buff);
if (pdev) {
/* We are not going to use this spi_device, so free it */
spi_dev_put(spi_device);
/*
* There is already a device configured for this bus.cs
* It is okay if it us, otherwise complain and fail.
*/
if (pdev->driver && pdev->driver->name &&
strcmp(this_driver_name, pdev->driver->name)) {
printk(KERN_ALERT
"Driver [%s] already registered for %s\n",
pdev->driver->name, buff);
status = -1;
}
} else {
spi_device->max_speed_hz = SPI_BUS_SPEED;
spi_device->mode = SPI_MODE_0;
spi_device->bits_per_word = 8;
spi_device->irq = -1;
spi_device->controller_state = NULL;
spi_device->controller_data = NULL;
strlcpy(spi_device->modalias, this_driver_name, SPI_NAME_SIZE);
status = spi_add_device(spi_device);
if (status < 0) {
spi_dev_put(spi_device);
printk(KERN_ALERT "spi_add_device() failed: %d\n",
status);
}
}
put_device(&spi_master->dev);
return status;
}
static int __init mt7697spi_init(void)
{
char str[32];
struct spi_master *master = NULL;
struct device *dev;
struct spi_device *spi;
struct mt7697q_info *qinfo = NULL;
int bus_num = MT7697_SPI_BUS_NUM;
int ret = 0;
pr_info(DRVNAME" %s(): '%s' initialize\n", __func__, DRVNAME);
while (!master && (bus_num >= 0)) {
master = spi_busnum_to_master(bus_num);
if (!master)
bus_num--;
}
if (!master) {
pr_err(DRVNAME" spi_busnum_to_master() failed\n");
ret = -EINVAL;
goto cleanup;
}
ret = cp2130_update_ch_config(master, MT7697_SPI_CONFIG);
if (ret < 0) {
dev_err(&master->dev,
"%s(): cp2130_update_ch_config() failed(%d)\n",
__func__, ret);
goto cleanup;
}
snprintf(str, sizeof(str), "%s.%u", dev_name(&master->dev),
MT7697_SPI_CS);
dev_info(&master->dev, "%s(): find SPI device('%s')\n", __func__, str);
dev = bus_find_device_by_name(&spi_bus_type, NULL, str);
if (!dev) {
dev_err(&master->dev,
"%s(): bus_find_device_by_name('%s') failed\n",
__func__, str);
ret = -EINVAL;
goto cleanup;
}
spi = to_spi_device(dev);
if (!spi) {
dev_err(&master->dev, "%s(): get SPI device failed\n",
__func__);
ret = -EINVAL;
goto cleanup;
}
dev_info(&master->dev, "%s(): dev('%s') mode(%d) max speed(%d) "
"CS(%d) bits/word(%d)\n",
__func__, spi->modalias, spi->mode, spi->max_speed_hz,
spi->chip_select, spi->bits_per_word);
qinfo = kzalloc(sizeof(struct mt7697q_info), GFP_KERNEL);
if (!qinfo) {
dev_err(&master->dev, "%s(): create queue info failed\n",
__func__);
ret = -ENOMEM;
goto cleanup;
}
qinfo->dev = &spi->dev;
qinfo->hw_priv = spi;
qinfo->hw_ops = &hw_ops;
mutex_init(&qinfo->mutex);
INIT_DELAYED_WORK(&qinfo->irq_delayed_work, mt7697q_irq_delayed_work);
INIT_WORK(&qinfo->irq_work, mt7697q_irq_work);
qinfo->irq_workq = alloc_workqueue(DRVNAME"wq",
WQ_HIGHPRI | WQ_MEM_RECLAIM | WQ_UNBOUND, 1);
if (!qinfo->irq_workq) {
dev_err(qinfo->dev, "%s(): alloc_workqueue() failed\n",
__func__);
ret = -ENOMEM;
goto cleanup;
}
qinfo->gpio_pin = MT7697_SPI_INTR_GPIO_PIN;
ret = gpio_request(qinfo->gpio_pin, MT7697_SPI_GPIO_IRQ_NAME);
if (ret < 0) {
if (ret != -EBUSY) {
dev_err(qinfo->dev, "%s(): gpio_request() failed(%d)",
__func__, ret);
goto failed_workqueue;
}
qinfo->irq = gpio_to_irq(qinfo->gpio_pin);
qinfo->gpio_pin = MT7697_SPI_INTR_GPIO_PIN_INVALID;
} else {
gpio_direction_input(qinfo->gpio_pin);
qinfo->irq = gpio_to_irq(qinfo->gpio_pin);
}
dev_info(qinfo->dev, "%s(): request irq(%d)\n", __func__, qinfo->irq);
ret = request_irq(qinfo->irq, mt7697q_isr, 0, DRVNAME, qinfo);
if (ret < 0) {
dev_err(qinfo->dev, "%s(): request_irq() failed(%d)",
__func__, ret);
goto failed_gpio_req;
}
irq_set_irq_type(qinfo->irq, IRQ_TYPE_EDGE_BOTH);
spi_set_drvdata(spi, qinfo);
dev_info(qinfo->dev, "%s(): '%s' initialized\n", __func__, DRVNAME);
return 0;
failed_gpio_req:
if (qinfo->gpio_pin > 0) gpio_free(qinfo->gpio_pin);
failed_workqueue:
destroy_workqueue(qinfo->irq_workq);
cleanup:
if (qinfo) kfree(qinfo);
return ret;
}
static int __init p1852_sku8_panel_init(void)
{
int err;
struct resource *res;
struct platform_device *phost1x = NULL;
bool is_dt = of_have_populated_dt();
p1852_carveouts[1].base = tegra_carveout_start;
p1852_carveouts[1].size = tegra_carveout_size;
/* sku 8 has primary RGB out and secondary HDMI out */
tegra_disp1_device.dev.platform_data = &p1852_disp1_pdata;
tegra_disp2_device.dev.platform_data = &p1852_hdmi_pdata;
err = platform_add_devices(p1852_gfx_devices,
ARRAY_SIZE(p1852_gfx_devices));
#ifdef CONFIG_TEGRA_GRHOST
if (!is_dt)
phost1x = tegra3_register_host1x_devices();
else
phost1x = to_platform_device(bus_find_device_by_name(
&platform_bus_type, NULL, "host1x"));
if (!phost1x) {
pr_err("host1x devices registration failed\n");
return -EINVAL;
}
#endif
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_DC)
res = platform_get_resource_byname(&tegra_disp1_device,
IORESOURCE_MEM, "fbmem");
if (res) {
res->start = tegra_fb_start;
res->end = tegra_fb_start + tegra_fb_size - 1;
}
/*
* If the bootloader fb is valid, copy it to the fb, or else
* clear fb to avoid garbage on dispaly1.
*/
if (tegra_bootloader_fb_size)
__tegra_move_framebuffer(&p1852_nvmap_device,
tegra_fb_start, tegra_bootloader_fb_start,
min(tegra_fb_size, tegra_bootloader_fb_size));
else
__tegra_clear_framebuffer(&p1852_nvmap_device,
tegra_fb_start, tegra_fb_size);
if (!err) {
tegra_disp1_device.dev.parent = &phost1x->dev;
err = platform_device_register(&tegra_disp1_device);
}
res = platform_get_resource_byname(&tegra_disp2_device,
IORESOURCE_MEM, "fbmem");
if (res) {
res->start = tegra_fb2_start;
res->end = tegra_fb2_start + tegra_fb2_size - 1;
}
/*
* If the bootloader fb2 is valid, copy it to the fb2, or else
* clear fb2 to avoid garbage on dispaly2.
*/
if (tegra_bootloader_fb2_size)
__tegra_move_framebuffer(&p1852_nvmap_device,
tegra_fb2_start, tegra_bootloader_fb2_start,
min(tegra_fb2_size, tegra_bootloader_fb2_size));
else
__tegra_clear_framebuffer(&p1852_nvmap_device,
tegra_fb2_start, tegra_fb2_size);
if (!err) {
tegra_disp2_device.dev.parent = &phost1x->dev;
err = platform_device_register(&tegra_disp2_device);
}
#endif
#if defined(CONFIG_TEGRA_GRHOST) && defined(CONFIG_TEGRA_NVAVP)
if (!err) {
nvavp_device.dev.parent = &phost1x->dev;
err = platform_device_register(&nvavp_device);
}
#endif
return err;
}
static int __init add_nxtts_device_to_bus(void)
{
struct spi_master *spi_master;
struct spi_device *spi_device;
struct device *pdev;
char buff[64];
int status = 0;
/* This call returns a refcounted pointer to the relevant spi_master - the caller must release this pointer(device_put()) */
spi_master = spi_busnum_to_master(SPI_BUS);
if (!spi_master) {
printk(KERN_ALERT "spi_busnum_to_master(%d) returned NULL\n", SPI_BUS);
printk(KERN_ALERT "Missing modprobe omap2_mcspi?\n");
return -1;
}
spi_device = spi_alloc_device(spi_master);
if (!spi_device) {
printk(KERN_ALERT "spi_alloc_device() failed\n");
return -1;
}
spi_device->chip_select = SPI_BUS_CS0;
/* Check whether this SPI bus.cs is already claimed */
/* snprintf the c-way of formatting a string */
snprintf(buff, sizeof(buff), "%s.%u", dev_name(&spi_device->master->dev), spi_device->chip_select);
pdev = bus_find_device_by_name(spi_device->dev.bus, NULL, buff);
if (pdev) {
/* We are not going to use this spi_device, so free it. Since spi_device is not added then decrement the refcount */
spi_dev_put(spi_device);
/*
* There is already a device configured for this bus.cs
* It is okay if it us, otherwise complain and fail.
*/
if (pdev->driver && pdev->driver->name && strcmp(DEVICE_NAME, pdev->driver->name)) {
printk(KERN_ALERT "Driver [%s] already registered for %s\n", pdev->driver->name, buff);
status = -1;
}
} else {
spi_device->max_speed_hz = SPI_BUS_SPEED;
spi_device->mode = SPI_MODE_0;
spi_device->bits_per_word = SPI_BITS_PER_WORD;
spi_device->irq = -1;
spi_device->controller_state = NULL;
spi_device->controller_data = NULL;
strlcpy(spi_device->modalias, DEVICE_NAME, SPI_NAME_SIZE);
status = spi_add_device(spi_device);
if (status < 0) {
/* If spi_device is not added then decrement the refcount */
spi_dev_put(spi_device);
printk(KERN_ALERT "spi_add_device() failed: %d\n", status);
}
}
/* See comment for spi_busnum_to_master */
put_device(&spi_master->dev);
return status;
}
