mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 01:10:04 +00:00
![Greg Kroah-Hartman](/assets/img/avatar_default.png)
This reverts commit 82ef33af9d
. It turns
out these machines are still out there, and the original patch broke
them. So revert it, adding back the driver, so people's machines still
work properly.
Reported-by: James Cameron <quozl@laptop.org>
Cc: Shraddha Barke <shraddha.6596@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
205 lines
6.5 KiB
C
205 lines
6.5 KiB
C
/*
|
|
* Mainly by David Woodhouse, somewhat modified by Jordan Crouse
|
|
*
|
|
* Copyright © 2006-2007 Red Hat, Inc.
|
|
* Copyright © 2006-2007 Advanced Micro Devices, Inc.
|
|
* Copyright © 2009 VIA Technology, Inc.
|
|
* Copyright (c) 2010 Andres Salomon <dilinger@queued.net>
|
|
*
|
|
* This program is free software. You can redistribute it and/or
|
|
* modify it under the terms of version 2 of the GNU General Public
|
|
* License as published by the Free Software Foundation.
|
|
*/
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#include <linux/cs5535.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/delay.h>
|
|
#include <asm/olpc.h>
|
|
|
|
#include "olpc_dcon.h"
|
|
|
|
static int dcon_init_xo_1(struct dcon_priv *dcon)
|
|
{
|
|
unsigned char lob;
|
|
|
|
if (gpio_request(OLPC_GPIO_DCON_STAT0, "OLPC-DCON")) {
|
|
pr_err("failed to request STAT0 GPIO\n");
|
|
return -EIO;
|
|
}
|
|
if (gpio_request(OLPC_GPIO_DCON_STAT1, "OLPC-DCON")) {
|
|
pr_err("failed to request STAT1 GPIO\n");
|
|
goto err_gp_stat1;
|
|
}
|
|
if (gpio_request(OLPC_GPIO_DCON_IRQ, "OLPC-DCON")) {
|
|
pr_err("failed to request IRQ GPIO\n");
|
|
goto err_gp_irq;
|
|
}
|
|
if (gpio_request(OLPC_GPIO_DCON_LOAD, "OLPC-DCON")) {
|
|
pr_err("failed to request LOAD GPIO\n");
|
|
goto err_gp_load;
|
|
}
|
|
if (gpio_request(OLPC_GPIO_DCON_BLANK, "OLPC-DCON")) {
|
|
pr_err("failed to request BLANK GPIO\n");
|
|
goto err_gp_blank;
|
|
}
|
|
|
|
/* Turn off the event enable for GPIO7 just to be safe */
|
|
cs5535_gpio_clear(OLPC_GPIO_DCON_IRQ, GPIO_EVENTS_ENABLE);
|
|
|
|
/*
|
|
* Determine the current state by reading the GPIO bit; earlier
|
|
* stages of the boot process have established the state.
|
|
*
|
|
* Note that we read GPIO_OUTPUT_VAL rather than GPIO_READ_BACK here;
|
|
* this is because OFW will disable input for the pin and set a value..
|
|
* READ_BACK will only contain a valid value if input is enabled and
|
|
* then a value is set. So, future readings of the pin can use
|
|
* READ_BACK, but the first one cannot. Awesome, huh?
|
|
*/
|
|
dcon->curr_src = cs5535_gpio_isset(OLPC_GPIO_DCON_LOAD, GPIO_OUTPUT_VAL)
|
|
? DCON_SOURCE_CPU
|
|
: DCON_SOURCE_DCON;
|
|
dcon->pending_src = dcon->curr_src;
|
|
|
|
/* Set the directions for the GPIO pins */
|
|
gpio_direction_input(OLPC_GPIO_DCON_STAT0);
|
|
gpio_direction_input(OLPC_GPIO_DCON_STAT1);
|
|
gpio_direction_input(OLPC_GPIO_DCON_IRQ);
|
|
gpio_direction_input(OLPC_GPIO_DCON_BLANK);
|
|
gpio_direction_output(OLPC_GPIO_DCON_LOAD,
|
|
dcon->curr_src == DCON_SOURCE_CPU);
|
|
|
|
/* Set up the interrupt mappings */
|
|
|
|
/* Set the IRQ to pair 2 */
|
|
cs5535_gpio_setup_event(OLPC_GPIO_DCON_IRQ, 2, 0);
|
|
|
|
/* Enable group 2 to trigger the DCON interrupt */
|
|
cs5535_gpio_set_irq(2, DCON_IRQ);
|
|
|
|
/* Select edge level for interrupt (in PIC) */
|
|
lob = inb(0x4d0);
|
|
lob &= ~(1 << DCON_IRQ);
|
|
outb(lob, 0x4d0);
|
|
|
|
/* Register the interrupt handler */
|
|
if (request_irq(DCON_IRQ, &dcon_interrupt, 0, "DCON", dcon)) {
|
|
pr_err("failed to request DCON's irq\n");
|
|
goto err_req_irq;
|
|
}
|
|
|
|
/* Clear INV_EN for GPIO7 (DCONIRQ) */
|
|
cs5535_gpio_clear(OLPC_GPIO_DCON_IRQ, GPIO_INPUT_INVERT);
|
|
|
|
/* Enable filter for GPIO12 (DCONBLANK) */
|
|
cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_INPUT_FILTER);
|
|
|
|
/* Disable filter for GPIO7 */
|
|
cs5535_gpio_clear(OLPC_GPIO_DCON_IRQ, GPIO_INPUT_FILTER);
|
|
|
|
/* Disable event counter for GPIO7 (DCONIRQ) and GPIO12 (DCONBLANK) */
|
|
cs5535_gpio_clear(OLPC_GPIO_DCON_IRQ, GPIO_INPUT_EVENT_COUNT);
|
|
cs5535_gpio_clear(OLPC_GPIO_DCON_BLANK, GPIO_INPUT_EVENT_COUNT);
|
|
|
|
/* Add GPIO12 to the Filter Event Pair #7 */
|
|
cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_FE7_SEL);
|
|
|
|
/* Turn off negative Edge Enable for GPIO12 */
|
|
cs5535_gpio_clear(OLPC_GPIO_DCON_BLANK, GPIO_NEGATIVE_EDGE_EN);
|
|
|
|
/* Enable negative Edge Enable for GPIO7 */
|
|
cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_NEGATIVE_EDGE_EN);
|
|
|
|
/* Zero the filter amount for Filter Event Pair #7 */
|
|
cs5535_gpio_set(0, GPIO_FLTR7_AMOUNT);
|
|
|
|
/* Clear the negative edge status for GPIO7 and GPIO12 */
|
|
cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_NEGATIVE_EDGE_STS);
|
|
cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_NEGATIVE_EDGE_STS);
|
|
|
|
/* FIXME: Clear the positive status as well, just to be sure */
|
|
cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_POSITIVE_EDGE_STS);
|
|
cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_POSITIVE_EDGE_STS);
|
|
|
|
/* Enable events for GPIO7 (DCONIRQ) and GPIO12 (DCONBLANK) */
|
|
cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_EVENTS_ENABLE);
|
|
cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_EVENTS_ENABLE);
|
|
|
|
return 0;
|
|
|
|
err_req_irq:
|
|
gpio_free(OLPC_GPIO_DCON_BLANK);
|
|
err_gp_blank:
|
|
gpio_free(OLPC_GPIO_DCON_LOAD);
|
|
err_gp_load:
|
|
gpio_free(OLPC_GPIO_DCON_IRQ);
|
|
err_gp_irq:
|
|
gpio_free(OLPC_GPIO_DCON_STAT1);
|
|
err_gp_stat1:
|
|
gpio_free(OLPC_GPIO_DCON_STAT0);
|
|
return -EIO;
|
|
}
|
|
|
|
static void dcon_wiggle_xo_1(void)
|
|
{
|
|
int x;
|
|
|
|
/*
|
|
* According to HiMax, when powering the DCON up we should hold
|
|
* SMB_DATA high for 8 SMB_CLK cycles. This will force the DCON
|
|
* state machine to reset to a (sane) initial state. Mitch Bradley
|
|
* did some testing and discovered that holding for 16 SMB_CLK cycles
|
|
* worked a lot more reliably, so that's what we do here.
|
|
*
|
|
* According to the cs5536 spec, to set GPIO14 to SMB_CLK we must
|
|
* simultaneously set AUX1 IN/OUT to GPIO14; ditto for SMB_DATA and
|
|
* GPIO15.
|
|
*/
|
|
cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_VAL);
|
|
cs5535_gpio_set(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_VAL);
|
|
cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_ENABLE);
|
|
cs5535_gpio_set(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_ENABLE);
|
|
cs5535_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_AUX1);
|
|
cs5535_gpio_clear(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX1);
|
|
cs5535_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_AUX2);
|
|
cs5535_gpio_clear(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX2);
|
|
cs5535_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_INPUT_AUX1);
|
|
cs5535_gpio_clear(OLPC_GPIO_SMB_DATA, GPIO_INPUT_AUX1);
|
|
|
|
for (x = 0; x < 16; x++) {
|
|
udelay(5);
|
|
cs5535_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_VAL);
|
|
udelay(5);
|
|
cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_VAL);
|
|
}
|
|
udelay(5);
|
|
cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_AUX1);
|
|
cs5535_gpio_set(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX1);
|
|
cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_INPUT_AUX1);
|
|
cs5535_gpio_set(OLPC_GPIO_SMB_DATA, GPIO_INPUT_AUX1);
|
|
}
|
|
|
|
static void dcon_set_dconload_1(int val)
|
|
{
|
|
gpio_set_value(OLPC_GPIO_DCON_LOAD, val);
|
|
}
|
|
|
|
static int dcon_read_status_xo_1(u8 *status)
|
|
{
|
|
*status = gpio_get_value(OLPC_GPIO_DCON_STAT0);
|
|
*status |= gpio_get_value(OLPC_GPIO_DCON_STAT1) << 1;
|
|
|
|
/* Clear the negative edge status for GPIO7 */
|
|
cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_NEGATIVE_EDGE_STS);
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct dcon_platform_data dcon_pdata_xo_1 = {
|
|
.init = dcon_init_xo_1,
|
|
.bus_stabilize_wiggle = dcon_wiggle_xo_1,
|
|
.set_dconload = dcon_set_dconload_1,
|
|
.read_status = dcon_read_status_xo_1,
|
|
};
|