|
@@ -27,59 +27,6 @@
|
|
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
*/
|
|
|
|
|
|
-/*
|
|
|
|
-* Number BF537/6/4 BF561 BF533/2/1 BF549/8/4/2
|
|
|
|
-*
|
|
|
|
-* GPIO_0 PF0 PF0 PF0 PA0...PJ13
|
|
|
|
-* GPIO_1 PF1 PF1 PF1
|
|
|
|
-* GPIO_2 PF2 PF2 PF2
|
|
|
|
-* GPIO_3 PF3 PF3 PF3
|
|
|
|
-* GPIO_4 PF4 PF4 PF4
|
|
|
|
-* GPIO_5 PF5 PF5 PF5
|
|
|
|
-* GPIO_6 PF6 PF6 PF6
|
|
|
|
-* GPIO_7 PF7 PF7 PF7
|
|
|
|
-* GPIO_8 PF8 PF8 PF8
|
|
|
|
-* GPIO_9 PF9 PF9 PF9
|
|
|
|
-* GPIO_10 PF10 PF10 PF10
|
|
|
|
-* GPIO_11 PF11 PF11 PF11
|
|
|
|
-* GPIO_12 PF12 PF12 PF12
|
|
|
|
-* GPIO_13 PF13 PF13 PF13
|
|
|
|
-* GPIO_14 PF14 PF14 PF14
|
|
|
|
-* GPIO_15 PF15 PF15 PF15
|
|
|
|
-* GPIO_16 PG0 PF16
|
|
|
|
-* GPIO_17 PG1 PF17
|
|
|
|
-* GPIO_18 PG2 PF18
|
|
|
|
-* GPIO_19 PG3 PF19
|
|
|
|
-* GPIO_20 PG4 PF20
|
|
|
|
-* GPIO_21 PG5 PF21
|
|
|
|
-* GPIO_22 PG6 PF22
|
|
|
|
-* GPIO_23 PG7 PF23
|
|
|
|
-* GPIO_24 PG8 PF24
|
|
|
|
-* GPIO_25 PG9 PF25
|
|
|
|
-* GPIO_26 PG10 PF26
|
|
|
|
-* GPIO_27 PG11 PF27
|
|
|
|
-* GPIO_28 PG12 PF28
|
|
|
|
-* GPIO_29 PG13 PF29
|
|
|
|
-* GPIO_30 PG14 PF30
|
|
|
|
-* GPIO_31 PG15 PF31
|
|
|
|
-* GPIO_32 PH0 PF32
|
|
|
|
-* GPIO_33 PH1 PF33
|
|
|
|
-* GPIO_34 PH2 PF34
|
|
|
|
-* GPIO_35 PH3 PF35
|
|
|
|
-* GPIO_36 PH4 PF36
|
|
|
|
-* GPIO_37 PH5 PF37
|
|
|
|
-* GPIO_38 PH6 PF38
|
|
|
|
-* GPIO_39 PH7 PF39
|
|
|
|
-* GPIO_40 PH8 PF40
|
|
|
|
-* GPIO_41 PH9 PF41
|
|
|
|
-* GPIO_42 PH10 PF42
|
|
|
|
-* GPIO_43 PH11 PF43
|
|
|
|
-* GPIO_44 PH12 PF44
|
|
|
|
-* GPIO_45 PH13 PF45
|
|
|
|
-* GPIO_46 PH14 PF46
|
|
|
|
-* GPIO_47 PH15 PF47
|
|
|
|
-*/
|
|
|
|
-
|
|
|
|
#include <linux/delay.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/module.h>
|
|
#include <linux/module.h>
|
|
#include <linux/err.h>
|
|
#include <linux/err.h>
|
|
@@ -119,62 +66,61 @@ enum {
|
|
#define AWA_DUMMY_READ(...) do { } while (0)
|
|
#define AWA_DUMMY_READ(...) do { } while (0)
|
|
#endif
|
|
#endif
|
|
|
|
|
|
|
|
+static struct gpio_port_t * const gpio_array[] = {
|
|
#if defined(BF533_FAMILY) || defined(BF538_FAMILY)
|
|
#if defined(BF533_FAMILY) || defined(BF538_FAMILY)
|
|
-static struct gpio_port_t *gpio_bankb[] = {
|
|
|
|
(struct gpio_port_t *) FIO_FLAG_D,
|
|
(struct gpio_port_t *) FIO_FLAG_D,
|
|
-};
|
|
|
|
-#endif
|
|
|
|
-
|
|
|
|
-#if defined(BF527_FAMILY) || defined(BF537_FAMILY) || defined(BF518_FAMILY)
|
|
|
|
-static struct gpio_port_t *gpio_bankb[] = {
|
|
|
|
|
|
+#elif defined(BF527_FAMILY) || defined(BF537_FAMILY) || defined(BF518_FAMILY)
|
|
(struct gpio_port_t *) PORTFIO,
|
|
(struct gpio_port_t *) PORTFIO,
|
|
(struct gpio_port_t *) PORTGIO,
|
|
(struct gpio_port_t *) PORTGIO,
|
|
(struct gpio_port_t *) PORTHIO,
|
|
(struct gpio_port_t *) PORTHIO,
|
|
|
|
+#elif defined(BF561_FAMILY)
|
|
|
|
+ (struct gpio_port_t *) FIO0_FLAG_D,
|
|
|
|
+ (struct gpio_port_t *) FIO1_FLAG_D,
|
|
|
|
+ (struct gpio_port_t *) FIO2_FLAG_D,
|
|
|
|
+#elif defined(BF548_FAMILY)
|
|
|
|
+ (struct gpio_port_t *)PORTA_FER,
|
|
|
|
+ (struct gpio_port_t *)PORTB_FER,
|
|
|
|
+ (struct gpio_port_t *)PORTC_FER,
|
|
|
|
+ (struct gpio_port_t *)PORTD_FER,
|
|
|
|
+ (struct gpio_port_t *)PORTE_FER,
|
|
|
|
+ (struct gpio_port_t *)PORTF_FER,
|
|
|
|
+ (struct gpio_port_t *)PORTG_FER,
|
|
|
|
+ (struct gpio_port_t *)PORTH_FER,
|
|
|
|
+ (struct gpio_port_t *)PORTI_FER,
|
|
|
|
+ (struct gpio_port_t *)PORTJ_FER,
|
|
|
|
+#else
|
|
|
|
+# error no gpio arrays defined
|
|
|
|
+#endif
|
|
};
|
|
};
|
|
|
|
|
|
-static unsigned short *port_fer[] = {
|
|
|
|
|
|
+#if defined(BF527_FAMILY) || defined(BF537_FAMILY) || defined(BF518_FAMILY)
|
|
|
|
+static unsigned short * const port_fer[] = {
|
|
(unsigned short *) PORTF_FER,
|
|
(unsigned short *) PORTF_FER,
|
|
(unsigned short *) PORTG_FER,
|
|
(unsigned short *) PORTG_FER,
|
|
(unsigned short *) PORTH_FER,
|
|
(unsigned short *) PORTH_FER,
|
|
};
|
|
};
|
|
-#endif
|
|
|
|
|
|
|
|
-#if defined(BF527_FAMILY) || defined(BF518_FAMILY)
|
|
|
|
-static unsigned short *port_mux[] = {
|
|
|
|
|
|
+# if !defined(BF537_FAMILY)
|
|
|
|
+static unsigned short * const port_mux[] = {
|
|
(unsigned short *) PORTF_MUX,
|
|
(unsigned short *) PORTF_MUX,
|
|
(unsigned short *) PORTG_MUX,
|
|
(unsigned short *) PORTG_MUX,
|
|
(unsigned short *) PORTH_MUX,
|
|
(unsigned short *) PORTH_MUX,
|
|
};
|
|
};
|
|
|
|
|
|
static const
|
|
static const
|
|
-u8 pmux_offset[][16] =
|
|
|
|
- {{ 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 4, 6, 8, 8, 10, 10 }, /* PORTF */
|
|
|
|
- { 0, 0, 0, 0, 0, 2, 2, 4, 4, 6, 8, 10, 10, 10, 12, 12 }, /* PORTG */
|
|
|
|
- { 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 4, 4, 4, 4, 4, 4 }, /* PORTH */
|
|
|
|
- };
|
|
|
|
-#endif
|
|
|
|
-
|
|
|
|
-#ifdef BF561_FAMILY
|
|
|
|
-static struct gpio_port_t *gpio_bankb[] = {
|
|
|
|
- (struct gpio_port_t *) FIO0_FLAG_D,
|
|
|
|
- (struct gpio_port_t *) FIO1_FLAG_D,
|
|
|
|
- (struct gpio_port_t *) FIO2_FLAG_D,
|
|
|
|
|
|
+u8 pmux_offset[][16] = {
|
|
|
|
+# if defined(BF527_FAMILY)
|
|
|
|
+ { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 4, 6, 8, 8, 10, 10 }, /* PORTF */
|
|
|
|
+ { 0, 0, 0, 0, 0, 2, 2, 4, 4, 6, 8, 10, 10, 10, 12, 12 }, /* PORTG */
|
|
|
|
+ { 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 4, 4, 4, 4, 4, 4 }, /* PORTH */
|
|
|
|
+# elif defined(BF518_FAMILY)
|
|
|
|
+ { 0, 2, 2, 2, 2, 2, 2, 4, 6, 6, 6, 8, 8, 8, 8, 10 }, /* PORTF */
|
|
|
|
+ { 0, 0, 0, 2, 4, 6, 6, 6, 8, 10, 10, 12, 14, 14, 14, 14 }, /* PORTG */
|
|
|
|
+ { 0, 0, 0, 0, 2, 2, 4, 6, 10, 10, 10, 10, 10, 10, 10, 10 }, /* PORTH */
|
|
|
|
+# endif
|
|
};
|
|
};
|
|
-#endif
|
|
|
|
|
|
+# endif
|
|
|
|
|
|
-#ifdef BF548_FAMILY
|
|
|
|
-static struct gpio_port_t *gpio_array[] = {
|
|
|
|
- (struct gpio_port_t *)PORTA_FER,
|
|
|
|
- (struct gpio_port_t *)PORTB_FER,
|
|
|
|
- (struct gpio_port_t *)PORTC_FER,
|
|
|
|
- (struct gpio_port_t *)PORTD_FER,
|
|
|
|
- (struct gpio_port_t *)PORTE_FER,
|
|
|
|
- (struct gpio_port_t *)PORTF_FER,
|
|
|
|
- (struct gpio_port_t *)PORTG_FER,
|
|
|
|
- (struct gpio_port_t *)PORTH_FER,
|
|
|
|
- (struct gpio_port_t *)PORTI_FER,
|
|
|
|
- (struct gpio_port_t *)PORTJ_FER,
|
|
|
|
-};
|
|
|
|
#endif
|
|
#endif
|
|
|
|
|
|
static unsigned short reserved_gpio_map[GPIO_BANK_NUM];
|
|
static unsigned short reserved_gpio_map[GPIO_BANK_NUM];
|
|
@@ -188,35 +134,9 @@ static struct str_ident {
|
|
} str_ident[MAX_RESOURCES];
|
|
} str_ident[MAX_RESOURCES];
|
|
|
|
|
|
#if defined(CONFIG_PM)
|
|
#if defined(CONFIG_PM)
|
|
-#if defined(CONFIG_BF54x)
|
|
|
|
-static struct gpio_port_s gpio_bank_saved[GPIO_BANK_NUM];
|
|
|
|
-#else
|
|
|
|
-static unsigned short wakeup_map[GPIO_BANK_NUM];
|
|
|
|
-static unsigned char wakeup_flags_map[MAX_BLACKFIN_GPIOS];
|
|
|
|
static struct gpio_port_s gpio_bank_saved[GPIO_BANK_NUM];
|
|
static struct gpio_port_s gpio_bank_saved[GPIO_BANK_NUM];
|
|
-
|
|
|
|
-#ifdef BF533_FAMILY
|
|
|
|
-static unsigned int sic_iwr_irqs[] = {IRQ_PROG_INTB};
|
|
|
|
-#endif
|
|
|
|
-
|
|
|
|
-#ifdef BF537_FAMILY
|
|
|
|
-static unsigned int sic_iwr_irqs[] = {IRQ_PROG_INTB, IRQ_PORTG_INTB, IRQ_MAC_TX};
|
|
|
|
-#endif
|
|
|
|
-
|
|
|
|
-#ifdef BF538_FAMILY
|
|
|
|
-static unsigned int sic_iwr_irqs[] = {IRQ_PORTF_INTB};
|
|
|
|
#endif
|
|
#endif
|
|
|
|
|
|
-#if defined(BF527_FAMILY) || defined(BF518_FAMILY)
|
|
|
|
-static unsigned int sic_iwr_irqs[] = {IRQ_PORTF_INTB, IRQ_PORTG_INTB, IRQ_PORTH_INTB};
|
|
|
|
-#endif
|
|
|
|
-
|
|
|
|
-#ifdef BF561_FAMILY
|
|
|
|
-static unsigned int sic_iwr_irqs[] = {IRQ_PROG0_INTB, IRQ_PROG1_INTB, IRQ_PROG2_INTB};
|
|
|
|
-#endif
|
|
|
|
-#endif
|
|
|
|
-#endif /* CONFIG_PM */
|
|
|
|
-
|
|
|
|
inline int check_gpio(unsigned gpio)
|
|
inline int check_gpio(unsigned gpio)
|
|
{
|
|
{
|
|
#if defined(BF548_FAMILY)
|
|
#if defined(BF548_FAMILY)
|
|
@@ -330,9 +250,10 @@ static struct {
|
|
{.res = P_SPI0_SSEL3, .offset = 0},
|
|
{.res = P_SPI0_SSEL3, .offset = 0},
|
|
};
|
|
};
|
|
|
|
|
|
-static void portmux_setup(unsigned short per, unsigned short function)
|
|
|
|
|
|
+static void portmux_setup(unsigned short per)
|
|
{
|
|
{
|
|
u16 y, offset, muxreg;
|
|
u16 y, offset, muxreg;
|
|
|
|
+ u16 function = P_FUNCT2MUX(per);
|
|
|
|
|
|
for (y = 0; y < ARRAY_SIZE(port_mux_lut); y++) {
|
|
for (y = 0; y < ARRAY_SIZE(port_mux_lut); y++) {
|
|
if (port_mux_lut[y].res == per) {
|
|
if (port_mux_lut[y].res == per) {
|
|
@@ -353,30 +274,33 @@ static void portmux_setup(unsigned short per, unsigned short function)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#elif defined(BF548_FAMILY)
|
|
#elif defined(BF548_FAMILY)
|
|
-inline void portmux_setup(unsigned short portno, unsigned short function)
|
|
|
|
|
|
+inline void portmux_setup(unsigned short per)
|
|
{
|
|
{
|
|
u32 pmux;
|
|
u32 pmux;
|
|
|
|
+ u16 ident = P_IDENT(per);
|
|
|
|
+ u16 function = P_FUNCT2MUX(per);
|
|
|
|
|
|
- pmux = gpio_array[gpio_bank(portno)]->port_mux;
|
|
|
|
|
|
+ pmux = gpio_array[gpio_bank(ident)]->port_mux;
|
|
|
|
|
|
- pmux &= ~(0x3 << (2 * gpio_sub_n(portno)));
|
|
|
|
- pmux |= (function & 0x3) << (2 * gpio_sub_n(portno));
|
|
|
|
|
|
+ pmux &= ~(0x3 << (2 * gpio_sub_n(ident)));
|
|
|
|
+ pmux |= (function & 0x3) << (2 * gpio_sub_n(ident));
|
|
|
|
|
|
- gpio_array[gpio_bank(portno)]->port_mux = pmux;
|
|
|
|
|
|
+ gpio_array[gpio_bank(ident)]->port_mux = pmux;
|
|
}
|
|
}
|
|
|
|
|
|
-inline u16 get_portmux(unsigned short portno)
|
|
|
|
|
|
+inline u16 get_portmux(unsigned short per)
|
|
{
|
|
{
|
|
u32 pmux;
|
|
u32 pmux;
|
|
|
|
+ u16 ident = P_IDENT(per);
|
|
|
|
|
|
- pmux = gpio_array[gpio_bank(portno)]->port_mux;
|
|
|
|
|
|
+ pmux = gpio_array[gpio_bank(ident)]->port_mux;
|
|
|
|
|
|
- return (pmux >> (2 * gpio_sub_n(portno)) & 0x3);
|
|
|
|
|
|
+ return (pmux >> (2 * gpio_sub_n(ident)) & 0x3);
|
|
}
|
|
}
|
|
#elif defined(BF527_FAMILY) || defined(BF518_FAMILY)
|
|
#elif defined(BF527_FAMILY) || defined(BF518_FAMILY)
|
|
-inline void portmux_setup(unsigned short portno, unsigned short function)
|
|
|
|
|
|
+inline void portmux_setup(unsigned short per)
|
|
{
|
|
{
|
|
- u16 pmux, ident = P_IDENT(portno);
|
|
|
|
|
|
+ u16 pmux, ident = P_IDENT(per), function = P_FUNCT2MUX(per);
|
|
u8 offset = pmux_offset[gpio_bank(ident)][gpio_sub_n(ident)];
|
|
u8 offset = pmux_offset[gpio_bank(ident)][gpio_sub_n(ident)];
|
|
|
|
|
|
pmux = *port_mux[gpio_bank(ident)];
|
|
pmux = *port_mux[gpio_bank(ident)];
|
|
@@ -424,90 +348,71 @@ void set_gpio_ ## name(unsigned gpio, unsigned short arg) \
|
|
unsigned long flags; \
|
|
unsigned long flags; \
|
|
local_irq_save_hw(flags); \
|
|
local_irq_save_hw(flags); \
|
|
if (arg) \
|
|
if (arg) \
|
|
- gpio_bankb[gpio_bank(gpio)]->name |= gpio_bit(gpio); \
|
|
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->name |= gpio_bit(gpio); \
|
|
else \
|
|
else \
|
|
- gpio_bankb[gpio_bank(gpio)]->name &= ~gpio_bit(gpio); \
|
|
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->name &= ~gpio_bit(gpio); \
|
|
AWA_DUMMY_READ(name); \
|
|
AWA_DUMMY_READ(name); \
|
|
local_irq_restore_hw(flags); \
|
|
local_irq_restore_hw(flags); \
|
|
} \
|
|
} \
|
|
EXPORT_SYMBOL(set_gpio_ ## name);
|
|
EXPORT_SYMBOL(set_gpio_ ## name);
|
|
|
|
|
|
-SET_GPIO(dir)
|
|
|
|
-SET_GPIO(inen)
|
|
|
|
-SET_GPIO(polar)
|
|
|
|
-SET_GPIO(edge)
|
|
|
|
-SET_GPIO(both)
|
|
|
|
|
|
+SET_GPIO(dir) /* set_gpio_dir() */
|
|
|
|
+SET_GPIO(inen) /* set_gpio_inen() */
|
|
|
|
+SET_GPIO(polar) /* set_gpio_polar() */
|
|
|
|
+SET_GPIO(edge) /* set_gpio_edge() */
|
|
|
|
+SET_GPIO(both) /* set_gpio_both() */
|
|
|
|
|
|
|
|
|
|
-#if ANOMALY_05000311 || ANOMALY_05000323
|
|
|
|
#define SET_GPIO_SC(name) \
|
|
#define SET_GPIO_SC(name) \
|
|
void set_gpio_ ## name(unsigned gpio, unsigned short arg) \
|
|
void set_gpio_ ## name(unsigned gpio, unsigned short arg) \
|
|
{ \
|
|
{ \
|
|
unsigned long flags; \
|
|
unsigned long flags; \
|
|
- local_irq_save_hw(flags); \
|
|
|
|
- if (arg) \
|
|
|
|
- gpio_bankb[gpio_bank(gpio)]->name ## _set = gpio_bit(gpio); \
|
|
|
|
- else \
|
|
|
|
- gpio_bankb[gpio_bank(gpio)]->name ## _clear = gpio_bit(gpio); \
|
|
|
|
- AWA_DUMMY_READ(name); \
|
|
|
|
- local_irq_restore_hw(flags); \
|
|
|
|
-} \
|
|
|
|
-EXPORT_SYMBOL(set_gpio_ ## name);
|
|
|
|
-#else
|
|
|
|
-#define SET_GPIO_SC(name) \
|
|
|
|
-void set_gpio_ ## name(unsigned gpio, unsigned short arg) \
|
|
|
|
-{ \
|
|
|
|
|
|
+ if (ANOMALY_05000311 || ANOMALY_05000323) \
|
|
|
|
+ local_irq_save_hw(flags); \
|
|
if (arg) \
|
|
if (arg) \
|
|
- gpio_bankb[gpio_bank(gpio)]->name ## _set = gpio_bit(gpio); \
|
|
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->name ## _set = gpio_bit(gpio); \
|
|
else \
|
|
else \
|
|
- gpio_bankb[gpio_bank(gpio)]->name ## _clear = gpio_bit(gpio); \
|
|
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->name ## _clear = gpio_bit(gpio); \
|
|
|
|
+ if (ANOMALY_05000311 || ANOMALY_05000323) { \
|
|
|
|
+ AWA_DUMMY_READ(name); \
|
|
|
|
+ local_irq_restore_hw(flags); \
|
|
|
|
+ } \
|
|
} \
|
|
} \
|
|
EXPORT_SYMBOL(set_gpio_ ## name);
|
|
EXPORT_SYMBOL(set_gpio_ ## name);
|
|
-#endif
|
|
|
|
|
|
|
|
SET_GPIO_SC(maska)
|
|
SET_GPIO_SC(maska)
|
|
SET_GPIO_SC(maskb)
|
|
SET_GPIO_SC(maskb)
|
|
SET_GPIO_SC(data)
|
|
SET_GPIO_SC(data)
|
|
|
|
|
|
-#if ANOMALY_05000311 || ANOMALY_05000323
|
|
|
|
void set_gpio_toggle(unsigned gpio)
|
|
void set_gpio_toggle(unsigned gpio)
|
|
{
|
|
{
|
|
unsigned long flags;
|
|
unsigned long flags;
|
|
- local_irq_save_hw(flags);
|
|
|
|
- gpio_bankb[gpio_bank(gpio)]->toggle = gpio_bit(gpio);
|
|
|
|
- AWA_DUMMY_READ(toggle);
|
|
|
|
- local_irq_restore_hw(flags);
|
|
|
|
-}
|
|
|
|
-#else
|
|
|
|
-void set_gpio_toggle(unsigned gpio)
|
|
|
|
-{
|
|
|
|
- gpio_bankb[gpio_bank(gpio)]->toggle = gpio_bit(gpio);
|
|
|
|
|
|
+ if (ANOMALY_05000311 || ANOMALY_05000323)
|
|
|
|
+ local_irq_save_hw(flags);
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->toggle = gpio_bit(gpio);
|
|
|
|
+ if (ANOMALY_05000311 || ANOMALY_05000323) {
|
|
|
|
+ AWA_DUMMY_READ(toggle);
|
|
|
|
+ local_irq_restore_hw(flags);
|
|
|
|
+ }
|
|
}
|
|
}
|
|
-#endif
|
|
|
|
EXPORT_SYMBOL(set_gpio_toggle);
|
|
EXPORT_SYMBOL(set_gpio_toggle);
|
|
|
|
|
|
|
|
|
|
/*Set current PORT date (16-bit word)*/
|
|
/*Set current PORT date (16-bit word)*/
|
|
|
|
|
|
-#if ANOMALY_05000311 || ANOMALY_05000323
|
|
|
|
#define SET_GPIO_P(name) \
|
|
#define SET_GPIO_P(name) \
|
|
void set_gpiop_ ## name(unsigned gpio, unsigned short arg) \
|
|
void set_gpiop_ ## name(unsigned gpio, unsigned short arg) \
|
|
{ \
|
|
{ \
|
|
unsigned long flags; \
|
|
unsigned long flags; \
|
|
- local_irq_save_hw(flags); \
|
|
|
|
- gpio_bankb[gpio_bank(gpio)]->name = arg; \
|
|
|
|
- AWA_DUMMY_READ(name); \
|
|
|
|
- local_irq_restore_hw(flags); \
|
|
|
|
|
|
+ if (ANOMALY_05000311 || ANOMALY_05000323) \
|
|
|
|
+ local_irq_save_hw(flags); \
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->name = arg; \
|
|
|
|
+ if (ANOMALY_05000311 || ANOMALY_05000323) { \
|
|
|
|
+ AWA_DUMMY_READ(name); \
|
|
|
|
+ local_irq_restore_hw(flags); \
|
|
|
|
+ } \
|
|
} \
|
|
} \
|
|
EXPORT_SYMBOL(set_gpiop_ ## name);
|
|
EXPORT_SYMBOL(set_gpiop_ ## name);
|
|
-#else
|
|
|
|
-#define SET_GPIO_P(name) \
|
|
|
|
-void set_gpiop_ ## name(unsigned gpio, unsigned short arg) \
|
|
|
|
-{ \
|
|
|
|
- gpio_bankb[gpio_bank(gpio)]->name = arg; \
|
|
|
|
-} \
|
|
|
|
-EXPORT_SYMBOL(set_gpiop_ ## name);
|
|
|
|
-#endif
|
|
|
|
|
|
|
|
SET_GPIO_P(data)
|
|
SET_GPIO_P(data)
|
|
SET_GPIO_P(dir)
|
|
SET_GPIO_P(dir)
|
|
@@ -519,27 +424,21 @@ SET_GPIO_P(maska)
|
|
SET_GPIO_P(maskb)
|
|
SET_GPIO_P(maskb)
|
|
|
|
|
|
/* Get a specific bit */
|
|
/* Get a specific bit */
|
|
-#if ANOMALY_05000311 || ANOMALY_05000323
|
|
|
|
#define GET_GPIO(name) \
|
|
#define GET_GPIO(name) \
|
|
unsigned short get_gpio_ ## name(unsigned gpio) \
|
|
unsigned short get_gpio_ ## name(unsigned gpio) \
|
|
{ \
|
|
{ \
|
|
unsigned long flags; \
|
|
unsigned long flags; \
|
|
unsigned short ret; \
|
|
unsigned short ret; \
|
|
- local_irq_save_hw(flags); \
|
|
|
|
- ret = 0x01 & (gpio_bankb[gpio_bank(gpio)]->name >> gpio_sub_n(gpio)); \
|
|
|
|
- AWA_DUMMY_READ(name); \
|
|
|
|
- local_irq_restore_hw(flags); \
|
|
|
|
|
|
+ if (ANOMALY_05000311 || ANOMALY_05000323) \
|
|
|
|
+ local_irq_save_hw(flags); \
|
|
|
|
+ ret = 0x01 & (gpio_array[gpio_bank(gpio)]->name >> gpio_sub_n(gpio)); \
|
|
|
|
+ if (ANOMALY_05000311 || ANOMALY_05000323) { \
|
|
|
|
+ AWA_DUMMY_READ(name); \
|
|
|
|
+ local_irq_restore_hw(flags); \
|
|
|
|
+ } \
|
|
return ret; \
|
|
return ret; \
|
|
} \
|
|
} \
|
|
EXPORT_SYMBOL(get_gpio_ ## name);
|
|
EXPORT_SYMBOL(get_gpio_ ## name);
|
|
-#else
|
|
|
|
-#define GET_GPIO(name) \
|
|
|
|
-unsigned short get_gpio_ ## name(unsigned gpio) \
|
|
|
|
-{ \
|
|
|
|
- return (0x01 & (gpio_bankb[gpio_bank(gpio)]->name >> gpio_sub_n(gpio))); \
|
|
|
|
-} \
|
|
|
|
-EXPORT_SYMBOL(get_gpio_ ## name);
|
|
|
|
-#endif
|
|
|
|
|
|
|
|
GET_GPIO(data)
|
|
GET_GPIO(data)
|
|
GET_GPIO(dir)
|
|
GET_GPIO(dir)
|
|
@@ -552,27 +451,21 @@ GET_GPIO(maskb)
|
|
|
|
|
|
/*Get current PORT date (16-bit word)*/
|
|
/*Get current PORT date (16-bit word)*/
|
|
|
|
|
|
-#if ANOMALY_05000311 || ANOMALY_05000323
|
|
|
|
#define GET_GPIO_P(name) \
|
|
#define GET_GPIO_P(name) \
|
|
unsigned short get_gpiop_ ## name(unsigned gpio) \
|
|
unsigned short get_gpiop_ ## name(unsigned gpio) \
|
|
{ \
|
|
{ \
|
|
unsigned long flags; \
|
|
unsigned long flags; \
|
|
unsigned short ret; \
|
|
unsigned short ret; \
|
|
- local_irq_save_hw(flags); \
|
|
|
|
- ret = (gpio_bankb[gpio_bank(gpio)]->name); \
|
|
|
|
- AWA_DUMMY_READ(name); \
|
|
|
|
- local_irq_restore_hw(flags); \
|
|
|
|
|
|
+ if (ANOMALY_05000311 || ANOMALY_05000323) \
|
|
|
|
+ local_irq_save_hw(flags); \
|
|
|
|
+ ret = (gpio_array[gpio_bank(gpio)]->name); \
|
|
|
|
+ if (ANOMALY_05000311 || ANOMALY_05000323) { \
|
|
|
|
+ AWA_DUMMY_READ(name); \
|
|
|
|
+ local_irq_restore_hw(flags); \
|
|
|
|
+ } \
|
|
return ret; \
|
|
return ret; \
|
|
} \
|
|
} \
|
|
EXPORT_SYMBOL(get_gpiop_ ## name);
|
|
EXPORT_SYMBOL(get_gpiop_ ## name);
|
|
-#else
|
|
|
|
-#define GET_GPIO_P(name) \
|
|
|
|
-unsigned short get_gpiop_ ## name(unsigned gpio) \
|
|
|
|
-{ \
|
|
|
|
- return (gpio_bankb[gpio_bank(gpio)]->name);\
|
|
|
|
-} \
|
|
|
|
-EXPORT_SYMBOL(get_gpiop_ ## name);
|
|
|
|
-#endif
|
|
|
|
|
|
|
|
GET_GPIO_P(data)
|
|
GET_GPIO_P(data)
|
|
GET_GPIO_P(dir)
|
|
GET_GPIO_P(dir)
|
|
@@ -585,6 +478,26 @@ GET_GPIO_P(maskb)
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
#ifdef CONFIG_PM
|
|
|
|
+
|
|
|
|
+static unsigned short wakeup_map[GPIO_BANK_NUM];
|
|
|
|
+static unsigned char wakeup_flags_map[MAX_BLACKFIN_GPIOS];
|
|
|
|
+
|
|
|
|
+static const unsigned int sic_iwr_irqs[] = {
|
|
|
|
+#if defined(BF533_FAMILY)
|
|
|
|
+ IRQ_PROG_INTB
|
|
|
|
+#elif defined(BF537_FAMILY)
|
|
|
|
+ IRQ_PROG_INTB, IRQ_PORTG_INTB, IRQ_MAC_TX
|
|
|
|
+#elif defined(BF538_FAMILY)
|
|
|
|
+ IRQ_PORTF_INTB
|
|
|
|
+#elif defined(BF527_FAMILY) || defined(BF518_FAMILY)
|
|
|
|
+ IRQ_PORTF_INTB, IRQ_PORTG_INTB, IRQ_PORTH_INTB
|
|
|
|
+#elif defined(BF561_FAMILY)
|
|
|
|
+ IRQ_PROG0_INTB, IRQ_PROG1_INTB, IRQ_PROG2_INTB
|
|
|
|
+#else
|
|
|
|
+# error no SIC_IWR defined
|
|
|
|
+#endif
|
|
|
|
+};
|
|
|
|
+
|
|
/***********************************************************
|
|
/***********************************************************
|
|
*
|
|
*
|
|
* FUNCTIONS: Blackfin PM Setup API
|
|
* FUNCTIONS: Blackfin PM Setup API
|
|
@@ -669,18 +582,18 @@ u32 bfin_pm_standby_setup(void)
|
|
mask = wakeup_map[gpio_bank(i)];
|
|
mask = wakeup_map[gpio_bank(i)];
|
|
bank = gpio_bank(i);
|
|
bank = gpio_bank(i);
|
|
|
|
|
|
- gpio_bank_saved[bank].maskb = gpio_bankb[bank]->maskb;
|
|
|
|
- gpio_bankb[bank]->maskb = 0;
|
|
|
|
|
|
+ gpio_bank_saved[bank].maskb = gpio_array[bank]->maskb;
|
|
|
|
+ gpio_array[bank]->maskb = 0;
|
|
|
|
|
|
if (mask) {
|
|
if (mask) {
|
|
#if defined(BF527_FAMILY) || defined(BF537_FAMILY) || defined(BF518_FAMILY)
|
|
#if defined(BF527_FAMILY) || defined(BF537_FAMILY) || defined(BF518_FAMILY)
|
|
gpio_bank_saved[bank].fer = *port_fer[bank];
|
|
gpio_bank_saved[bank].fer = *port_fer[bank];
|
|
#endif
|
|
#endif
|
|
- gpio_bank_saved[bank].inen = gpio_bankb[bank]->inen;
|
|
|
|
- gpio_bank_saved[bank].polar = gpio_bankb[bank]->polar;
|
|
|
|
- gpio_bank_saved[bank].dir = gpio_bankb[bank]->dir;
|
|
|
|
- gpio_bank_saved[bank].edge = gpio_bankb[bank]->edge;
|
|
|
|
- gpio_bank_saved[bank].both = gpio_bankb[bank]->both;
|
|
|
|
|
|
+ gpio_bank_saved[bank].inen = gpio_array[bank]->inen;
|
|
|
|
+ gpio_bank_saved[bank].polar = gpio_array[bank]->polar;
|
|
|
|
+ gpio_bank_saved[bank].dir = gpio_array[bank]->dir;
|
|
|
|
+ gpio_bank_saved[bank].edge = gpio_array[bank]->edge;
|
|
|
|
+ gpio_bank_saved[bank].both = gpio_array[bank]->both;
|
|
gpio_bank_saved[bank].reserved =
|
|
gpio_bank_saved[bank].reserved =
|
|
reserved_gpio_map[bank];
|
|
reserved_gpio_map[bank];
|
|
|
|
|
|
@@ -700,7 +613,7 @@ u32 bfin_pm_standby_setup(void)
|
|
}
|
|
}
|
|
|
|
|
|
bfin_internal_set_wake(sic_iwr_irqs[bank], 1);
|
|
bfin_internal_set_wake(sic_iwr_irqs[bank], 1);
|
|
- gpio_bankb[bank]->maskb_set = wakeup_map[gpio_bank(i)];
|
|
|
|
|
|
+ gpio_array[bank]->maskb_set = wakeup_map[gpio_bank(i)];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@@ -721,18 +634,18 @@ void bfin_pm_standby_restore(void)
|
|
#if defined(BF527_FAMILY) || defined(BF537_FAMILY) || defined(BF518_FAMILY)
|
|
#if defined(BF527_FAMILY) || defined(BF537_FAMILY) || defined(BF518_FAMILY)
|
|
*port_fer[bank] = gpio_bank_saved[bank].fer;
|
|
*port_fer[bank] = gpio_bank_saved[bank].fer;
|
|
#endif
|
|
#endif
|
|
- gpio_bankb[bank]->inen = gpio_bank_saved[bank].inen;
|
|
|
|
- gpio_bankb[bank]->dir = gpio_bank_saved[bank].dir;
|
|
|
|
- gpio_bankb[bank]->polar = gpio_bank_saved[bank].polar;
|
|
|
|
- gpio_bankb[bank]->edge = gpio_bank_saved[bank].edge;
|
|
|
|
- gpio_bankb[bank]->both = gpio_bank_saved[bank].both;
|
|
|
|
|
|
+ gpio_array[bank]->inen = gpio_bank_saved[bank].inen;
|
|
|
|
+ gpio_array[bank]->dir = gpio_bank_saved[bank].dir;
|
|
|
|
+ gpio_array[bank]->polar = gpio_bank_saved[bank].polar;
|
|
|
|
+ gpio_array[bank]->edge = gpio_bank_saved[bank].edge;
|
|
|
|
+ gpio_array[bank]->both = gpio_bank_saved[bank].both;
|
|
|
|
|
|
reserved_gpio_map[bank] =
|
|
reserved_gpio_map[bank] =
|
|
gpio_bank_saved[bank].reserved;
|
|
gpio_bank_saved[bank].reserved;
|
|
bfin_internal_set_wake(sic_iwr_irqs[bank], 0);
|
|
bfin_internal_set_wake(sic_iwr_irqs[bank], 0);
|
|
}
|
|
}
|
|
|
|
|
|
- gpio_bankb[bank]->maskb = gpio_bank_saved[bank].maskb;
|
|
|
|
|
|
+ gpio_array[bank]->maskb = gpio_bank_saved[bank].maskb;
|
|
}
|
|
}
|
|
AWA_DUMMY_READ(maskb);
|
|
AWA_DUMMY_READ(maskb);
|
|
}
|
|
}
|
|
@@ -745,21 +658,21 @@ void bfin_gpio_pm_hibernate_suspend(void)
|
|
bank = gpio_bank(i);
|
|
bank = gpio_bank(i);
|
|
|
|
|
|
#if defined(BF527_FAMILY) || defined(BF537_FAMILY) || defined(BF518_FAMILY)
|
|
#if defined(BF527_FAMILY) || defined(BF537_FAMILY) || defined(BF518_FAMILY)
|
|
- gpio_bank_saved[bank].fer = *port_fer[bank];
|
|
|
|
|
|
+ gpio_bank_saved[bank].fer = *port_fer[bank];
|
|
#if defined(BF527_FAMILY) || defined(BF518_FAMILY)
|
|
#if defined(BF527_FAMILY) || defined(BF518_FAMILY)
|
|
- gpio_bank_saved[bank].mux = *port_mux[bank];
|
|
|
|
|
|
+ gpio_bank_saved[bank].mux = *port_mux[bank];
|
|
#else
|
|
#else
|
|
- if (bank == 0)
|
|
|
|
- gpio_bank_saved[bank].mux = bfin_read_PORT_MUX();
|
|
|
|
|
|
+ if (bank == 0)
|
|
|
|
+ gpio_bank_saved[bank].mux = bfin_read_PORT_MUX();
|
|
#endif
|
|
#endif
|
|
#endif
|
|
#endif
|
|
- gpio_bank_saved[bank].data = gpio_bankb[bank]->data;
|
|
|
|
- gpio_bank_saved[bank].inen = gpio_bankb[bank]->inen;
|
|
|
|
- gpio_bank_saved[bank].polar = gpio_bankb[bank]->polar;
|
|
|
|
- gpio_bank_saved[bank].dir = gpio_bankb[bank]->dir;
|
|
|
|
- gpio_bank_saved[bank].edge = gpio_bankb[bank]->edge;
|
|
|
|
- gpio_bank_saved[bank].both = gpio_bankb[bank]->both;
|
|
|
|
- gpio_bank_saved[bank].maska = gpio_bankb[bank]->maska;
|
|
|
|
|
|
+ gpio_bank_saved[bank].data = gpio_array[bank]->data;
|
|
|
|
+ gpio_bank_saved[bank].inen = gpio_array[bank]->inen;
|
|
|
|
+ gpio_bank_saved[bank].polar = gpio_array[bank]->polar;
|
|
|
|
+ gpio_bank_saved[bank].dir = gpio_array[bank]->dir;
|
|
|
|
+ gpio_bank_saved[bank].edge = gpio_array[bank]->edge;
|
|
|
|
+ gpio_bank_saved[bank].both = gpio_array[bank]->both;
|
|
|
|
+ gpio_bank_saved[bank].maska = gpio_array[bank]->maska;
|
|
}
|
|
}
|
|
|
|
|
|
AWA_DUMMY_READ(maska);
|
|
AWA_DUMMY_READ(maska);
|
|
@@ -770,27 +683,27 @@ void bfin_gpio_pm_hibernate_restore(void)
|
|
int i, bank;
|
|
int i, bank;
|
|
|
|
|
|
for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
|
|
for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
|
|
- bank = gpio_bank(i);
|
|
|
|
|
|
+ bank = gpio_bank(i);
|
|
|
|
|
|
#if defined(BF527_FAMILY) || defined(BF537_FAMILY) || defined(BF518_FAMILY)
|
|
#if defined(BF527_FAMILY) || defined(BF537_FAMILY) || defined(BF518_FAMILY)
|
|
#if defined(BF527_FAMILY) || defined(BF518_FAMILY)
|
|
#if defined(BF527_FAMILY) || defined(BF518_FAMILY)
|
|
- *port_mux[bank] = gpio_bank_saved[bank].mux;
|
|
|
|
|
|
+ *port_mux[bank] = gpio_bank_saved[bank].mux;
|
|
#else
|
|
#else
|
|
- if (bank == 0)
|
|
|
|
- bfin_write_PORT_MUX(gpio_bank_saved[bank].mux);
|
|
|
|
|
|
+ if (bank == 0)
|
|
|
|
+ bfin_write_PORT_MUX(gpio_bank_saved[bank].mux);
|
|
#endif
|
|
#endif
|
|
- *port_fer[bank] = gpio_bank_saved[bank].fer;
|
|
|
|
|
|
+ *port_fer[bank] = gpio_bank_saved[bank].fer;
|
|
#endif
|
|
#endif
|
|
- gpio_bankb[bank]->inen = gpio_bank_saved[bank].inen;
|
|
|
|
- gpio_bankb[bank]->dir = gpio_bank_saved[bank].dir;
|
|
|
|
- gpio_bankb[bank]->polar = gpio_bank_saved[bank].polar;
|
|
|
|
- gpio_bankb[bank]->edge = gpio_bank_saved[bank].edge;
|
|
|
|
- gpio_bankb[bank]->both = gpio_bank_saved[bank].both;
|
|
|
|
|
|
+ gpio_array[bank]->inen = gpio_bank_saved[bank].inen;
|
|
|
|
+ gpio_array[bank]->dir = gpio_bank_saved[bank].dir;
|
|
|
|
+ gpio_array[bank]->polar = gpio_bank_saved[bank].polar;
|
|
|
|
+ gpio_array[bank]->edge = gpio_bank_saved[bank].edge;
|
|
|
|
+ gpio_array[bank]->both = gpio_bank_saved[bank].both;
|
|
|
|
|
|
- gpio_bankb[bank]->data_set = gpio_bank_saved[bank].data
|
|
|
|
- | gpio_bank_saved[bank].dir;
|
|
|
|
|
|
+ gpio_array[bank]->data_set = gpio_bank_saved[bank].data
|
|
|
|
+ | gpio_bank_saved[bank].dir;
|
|
|
|
|
|
- gpio_bankb[bank]->maska = gpio_bank_saved[bank].maska;
|
|
|
|
|
|
+ gpio_array[bank]->maska = gpio_bank_saved[bank].maska;
|
|
}
|
|
}
|
|
AWA_DUMMY_READ(maska);
|
|
AWA_DUMMY_READ(maska);
|
|
}
|
|
}
|
|
@@ -817,12 +730,12 @@ void bfin_gpio_pm_hibernate_suspend(void)
|
|
for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
|
|
for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
|
|
bank = gpio_bank(i);
|
|
bank = gpio_bank(i);
|
|
|
|
|
|
- gpio_bank_saved[bank].fer = gpio_array[bank]->port_fer;
|
|
|
|
- gpio_bank_saved[bank].mux = gpio_array[bank]->port_mux;
|
|
|
|
- gpio_bank_saved[bank].data = gpio_array[bank]->port_data;
|
|
|
|
- gpio_bank_saved[bank].data = gpio_array[bank]->port_data;
|
|
|
|
- gpio_bank_saved[bank].inen = gpio_array[bank]->port_inen;
|
|
|
|
- gpio_bank_saved[bank].dir = gpio_array[bank]->port_dir_set;
|
|
|
|
|
|
+ gpio_bank_saved[bank].fer = gpio_array[bank]->port_fer;
|
|
|
|
+ gpio_bank_saved[bank].mux = gpio_array[bank]->port_mux;
|
|
|
|
+ gpio_bank_saved[bank].data = gpio_array[bank]->data;
|
|
|
|
+ gpio_bank_saved[bank].data = gpio_array[bank]->data;
|
|
|
|
+ gpio_bank_saved[bank].inen = gpio_array[bank]->inen;
|
|
|
|
+ gpio_bank_saved[bank].dir = gpio_array[bank]->dir_set;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@@ -831,21 +744,21 @@ void bfin_gpio_pm_hibernate_restore(void)
|
|
int i, bank;
|
|
int i, bank;
|
|
|
|
|
|
for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
|
|
for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
|
|
- bank = gpio_bank(i);
|
|
|
|
-
|
|
|
|
- gpio_array[bank]->port_mux = gpio_bank_saved[bank].mux;
|
|
|
|
- gpio_array[bank]->port_fer = gpio_bank_saved[bank].fer;
|
|
|
|
- gpio_array[bank]->port_inen = gpio_bank_saved[bank].inen;
|
|
|
|
- gpio_array[bank]->port_dir_set = gpio_bank_saved[bank].dir;
|
|
|
|
- gpio_array[bank]->port_set = gpio_bank_saved[bank].data
|
|
|
|
- | gpio_bank_saved[bank].dir;
|
|
|
|
|
|
+ bank = gpio_bank(i);
|
|
|
|
+
|
|
|
|
+ gpio_array[bank]->port_mux = gpio_bank_saved[bank].mux;
|
|
|
|
+ gpio_array[bank]->port_fer = gpio_bank_saved[bank].fer;
|
|
|
|
+ gpio_array[bank]->inen = gpio_bank_saved[bank].inen;
|
|
|
|
+ gpio_array[bank]->dir_set = gpio_bank_saved[bank].dir;
|
|
|
|
+ gpio_array[bank]->data_set = gpio_bank_saved[bank].data
|
|
|
|
+ | gpio_bank_saved[bank].dir;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
|
|
unsigned short get_gpio_dir(unsigned gpio)
|
|
unsigned short get_gpio_dir(unsigned gpio)
|
|
{
|
|
{
|
|
- return (0x01 & (gpio_array[gpio_bank(gpio)]->port_dir_clear >> gpio_sub_n(gpio)));
|
|
|
|
|
|
+ return (0x01 & (gpio_array[gpio_bank(gpio)]->dir_clear >> gpio_sub_n(gpio)));
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(get_gpio_dir);
|
|
EXPORT_SYMBOL(get_gpio_dir);
|
|
|
|
|
|
@@ -905,9 +818,7 @@ int peripheral_request(unsigned short per, const char *label)
|
|
*/
|
|
*/
|
|
|
|
|
|
#ifdef BF548_FAMILY
|
|
#ifdef BF548_FAMILY
|
|
- u16 funct = get_portmux(ident);
|
|
|
|
-
|
|
|
|
- if (!((per & P_MAYSHARE) && (funct == P_FUNCT2MUX(per)))) {
|
|
|
|
|
|
+ if (!((per & P_MAYSHARE) && get_portmux(per) == P_FUNCT2MUX(per))) {
|
|
#else
|
|
#else
|
|
if (!(per & P_MAYSHARE)) {
|
|
if (!(per & P_MAYSHARE)) {
|
|
#endif
|
|
#endif
|
|
@@ -931,11 +842,7 @@ int peripheral_request(unsigned short per, const char *label)
|
|
anyway:
|
|
anyway:
|
|
reserved_peri_map[gpio_bank(ident)] |= gpio_bit(ident);
|
|
reserved_peri_map[gpio_bank(ident)] |= gpio_bit(ident);
|
|
|
|
|
|
-#ifdef BF548_FAMILY
|
|
|
|
- portmux_setup(ident, P_FUNCT2MUX(per));
|
|
|
|
-#else
|
|
|
|
- portmux_setup(per, P_FUNCT2MUX(per));
|
|
|
|
-#endif
|
|
|
|
|
|
+ portmux_setup(per);
|
|
port_setup(ident, PERIPHERAL_USAGE);
|
|
port_setup(ident, PERIPHERAL_USAGE);
|
|
|
|
|
|
local_irq_restore_hw(flags);
|
|
local_irq_restore_hw(flags);
|
|
@@ -977,9 +884,6 @@ void peripheral_free(unsigned short per)
|
|
if (!(per & P_DEFINED))
|
|
if (!(per & P_DEFINED))
|
|
return;
|
|
return;
|
|
|
|
|
|
- if (check_gpio(ident) < 0)
|
|
|
|
- return;
|
|
|
|
-
|
|
|
|
local_irq_save_hw(flags);
|
|
local_irq_save_hw(flags);
|
|
|
|
|
|
if (unlikely(!(reserved_peri_map[gpio_bank(ident)] & gpio_bit(ident)))) {
|
|
if (unlikely(!(reserved_peri_map[gpio_bank(ident)] & gpio_bit(ident)))) {
|
|
@@ -1056,9 +960,15 @@ int bfin_gpio_request(unsigned gpio, const char *label)
|
|
local_irq_restore_hw(flags);
|
|
local_irq_restore_hw(flags);
|
|
return -EBUSY;
|
|
return -EBUSY;
|
|
}
|
|
}
|
|
- if (unlikely(reserved_gpio_irq_map[gpio_bank(gpio)] & gpio_bit(gpio)))
|
|
|
|
|
|
+ if (unlikely(reserved_gpio_irq_map[gpio_bank(gpio)] & gpio_bit(gpio))) {
|
|
printk(KERN_NOTICE "bfin-gpio: GPIO %d is already reserved as gpio-irq!"
|
|
printk(KERN_NOTICE "bfin-gpio: GPIO %d is already reserved as gpio-irq!"
|
|
" (Documentation/blackfin/bfin-gpio-notes.txt)\n", gpio);
|
|
" (Documentation/blackfin/bfin-gpio-notes.txt)\n", gpio);
|
|
|
|
+ }
|
|
|
|
+#ifndef BF548_FAMILY
|
|
|
|
+ else { /* Reset POLAR setting when acquiring a gpio for the first time */
|
|
|
|
+ set_gpio_polar(gpio, 0);
|
|
|
|
+ }
|
|
|
|
+#endif
|
|
|
|
|
|
reserved_gpio_map[gpio_bank(gpio)] |= gpio_bit(gpio);
|
|
reserved_gpio_map[gpio_bank(gpio)] |= gpio_bit(gpio);
|
|
set_label(gpio, label);
|
|
set_label(gpio, label);
|
|
@@ -1078,6 +988,8 @@ void bfin_gpio_free(unsigned gpio)
|
|
if (check_gpio(gpio) < 0)
|
|
if (check_gpio(gpio) < 0)
|
|
return;
|
|
return;
|
|
|
|
|
|
|
|
+ might_sleep();
|
|
|
|
+
|
|
local_irq_save_hw(flags);
|
|
local_irq_save_hw(flags);
|
|
|
|
|
|
if (unlikely(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio)))) {
|
|
if (unlikely(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio)))) {
|
|
@@ -1158,8 +1070,16 @@ void bfin_gpio_irq_free(unsigned gpio)
|
|
local_irq_restore_hw(flags);
|
|
local_irq_restore_hw(flags);
|
|
}
|
|
}
|
|
|
|
|
|
-
|
|
|
|
|
|
+static inline void __bfin_gpio_direction_input(unsigned gpio)
|
|
|
|
+{
|
|
#ifdef BF548_FAMILY
|
|
#ifdef BF548_FAMILY
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->dir_clear = gpio_bit(gpio);
|
|
|
|
+#else
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->dir &= ~gpio_bit(gpio);
|
|
|
|
+#endif
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->inen |= gpio_bit(gpio);
|
|
|
|
+}
|
|
|
|
+
|
|
int bfin_gpio_direction_input(unsigned gpio)
|
|
int bfin_gpio_direction_input(unsigned gpio)
|
|
{
|
|
{
|
|
unsigned long flags;
|
|
unsigned long flags;
|
|
@@ -1170,125 +1090,85 @@ int bfin_gpio_direction_input(unsigned gpio)
|
|
}
|
|
}
|
|
|
|
|
|
local_irq_save_hw(flags);
|
|
local_irq_save_hw(flags);
|
|
- gpio_array[gpio_bank(gpio)]->port_dir_clear = gpio_bit(gpio);
|
|
|
|
- gpio_array[gpio_bank(gpio)]->port_inen |= gpio_bit(gpio);
|
|
|
|
|
|
+ __bfin_gpio_direction_input(gpio);
|
|
|
|
+ AWA_DUMMY_READ(inen);
|
|
local_irq_restore_hw(flags);
|
|
local_irq_restore_hw(flags);
|
|
|
|
|
|
return 0;
|
|
return 0;
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(bfin_gpio_direction_input);
|
|
EXPORT_SYMBOL(bfin_gpio_direction_input);
|
|
|
|
|
|
-int bfin_gpio_direction_output(unsigned gpio, int value)
|
|
|
|
|
|
+void bfin_gpio_irq_prepare(unsigned gpio)
|
|
{
|
|
{
|
|
|
|
+#ifdef BF548_FAMILY
|
|
unsigned long flags;
|
|
unsigned long flags;
|
|
|
|
+#endif
|
|
|
|
|
|
- if (!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))) {
|
|
|
|
- gpio_error(gpio);
|
|
|
|
- return -EINVAL;
|
|
|
|
- }
|
|
|
|
|
|
+ port_setup(gpio, GPIO_USAGE);
|
|
|
|
|
|
|
|
+#ifdef BF548_FAMILY
|
|
local_irq_save_hw(flags);
|
|
local_irq_save_hw(flags);
|
|
- gpio_array[gpio_bank(gpio)]->port_inen &= ~gpio_bit(gpio);
|
|
|
|
- gpio_set_value(gpio, value);
|
|
|
|
- gpio_array[gpio_bank(gpio)]->port_dir_set = gpio_bit(gpio);
|
|
|
|
|
|
+ __bfin_gpio_direction_input(gpio);
|
|
local_irq_restore_hw(flags);
|
|
local_irq_restore_hw(flags);
|
|
-
|
|
|
|
- return 0;
|
|
|
|
|
|
+#endif
|
|
}
|
|
}
|
|
-EXPORT_SYMBOL(bfin_gpio_direction_output);
|
|
|
|
|
|
|
|
void bfin_gpio_set_value(unsigned gpio, int arg)
|
|
void bfin_gpio_set_value(unsigned gpio, int arg)
|
|
{
|
|
{
|
|
if (arg)
|
|
if (arg)
|
|
- gpio_array[gpio_bank(gpio)]->port_set = gpio_bit(gpio);
|
|
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->data_set = gpio_bit(gpio);
|
|
else
|
|
else
|
|
- gpio_array[gpio_bank(gpio)]->port_clear = gpio_bit(gpio);
|
|
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->data_clear = gpio_bit(gpio);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(bfin_gpio_set_value);
|
|
EXPORT_SYMBOL(bfin_gpio_set_value);
|
|
|
|
|
|
-int bfin_gpio_get_value(unsigned gpio)
|
|
|
|
-{
|
|
|
|
- return (1 & (gpio_array[gpio_bank(gpio)]->port_data >> gpio_sub_n(gpio)));
|
|
|
|
-}
|
|
|
|
-EXPORT_SYMBOL(bfin_gpio_get_value);
|
|
|
|
-
|
|
|
|
-void bfin_gpio_irq_prepare(unsigned gpio)
|
|
|
|
|
|
+int bfin_gpio_direction_output(unsigned gpio, int value)
|
|
{
|
|
{
|
|
unsigned long flags;
|
|
unsigned long flags;
|
|
|
|
|
|
- port_setup(gpio, GPIO_USAGE);
|
|
|
|
|
|
+ if (!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))) {
|
|
|
|
+ gpio_error(gpio);
|
|
|
|
+ return -EINVAL;
|
|
|
|
+ }
|
|
|
|
|
|
local_irq_save_hw(flags);
|
|
local_irq_save_hw(flags);
|
|
- gpio_array[gpio_bank(gpio)]->port_dir_clear = gpio_bit(gpio);
|
|
|
|
- gpio_array[gpio_bank(gpio)]->port_inen |= gpio_bit(gpio);
|
|
|
|
- local_irq_restore_hw(flags);
|
|
|
|
-}
|
|
|
|
|
|
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->inen &= ~gpio_bit(gpio);
|
|
|
|
+ gpio_set_value(gpio, value);
|
|
|
|
+#ifdef BF548_FAMILY
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->dir_set = gpio_bit(gpio);
|
|
#else
|
|
#else
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->dir |= gpio_bit(gpio);
|
|
|
|
+#endif
|
|
|
|
+
|
|
|
|
+ AWA_DUMMY_READ(dir);
|
|
|
|
+ local_irq_restore_hw(flags);
|
|
|
|
+
|
|
|
|
+ return 0;
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL(bfin_gpio_direction_output);
|
|
|
|
|
|
int bfin_gpio_get_value(unsigned gpio)
|
|
int bfin_gpio_get_value(unsigned gpio)
|
|
{
|
|
{
|
|
|
|
+#ifdef BF548_FAMILY
|
|
|
|
+ return (1 & (gpio_array[gpio_bank(gpio)]->data >> gpio_sub_n(gpio)));
|
|
|
|
+#else
|
|
unsigned long flags;
|
|
unsigned long flags;
|
|
- int ret;
|
|
|
|
|
|
|
|
if (unlikely(get_gpio_edge(gpio))) {
|
|
if (unlikely(get_gpio_edge(gpio))) {
|
|
|
|
+ int ret;
|
|
local_irq_save_hw(flags);
|
|
local_irq_save_hw(flags);
|
|
set_gpio_edge(gpio, 0);
|
|
set_gpio_edge(gpio, 0);
|
|
ret = get_gpio_data(gpio);
|
|
ret = get_gpio_data(gpio);
|
|
set_gpio_edge(gpio, 1);
|
|
set_gpio_edge(gpio, 1);
|
|
local_irq_restore_hw(flags);
|
|
local_irq_restore_hw(flags);
|
|
-
|
|
|
|
return ret;
|
|
return ret;
|
|
} else
|
|
} else
|
|
return get_gpio_data(gpio);
|
|
return get_gpio_data(gpio);
|
|
|
|
+#endif
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(bfin_gpio_get_value);
|
|
EXPORT_SYMBOL(bfin_gpio_get_value);
|
|
|
|
|
|
-
|
|
|
|
-int bfin_gpio_direction_input(unsigned gpio)
|
|
|
|
-{
|
|
|
|
- unsigned long flags;
|
|
|
|
-
|
|
|
|
- if (!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))) {
|
|
|
|
- gpio_error(gpio);
|
|
|
|
- return -EINVAL;
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- local_irq_save_hw(flags);
|
|
|
|
- gpio_bankb[gpio_bank(gpio)]->dir &= ~gpio_bit(gpio);
|
|
|
|
- gpio_bankb[gpio_bank(gpio)]->inen |= gpio_bit(gpio);
|
|
|
|
- AWA_DUMMY_READ(inen);
|
|
|
|
- local_irq_restore_hw(flags);
|
|
|
|
-
|
|
|
|
- return 0;
|
|
|
|
-}
|
|
|
|
-EXPORT_SYMBOL(bfin_gpio_direction_input);
|
|
|
|
-
|
|
|
|
-int bfin_gpio_direction_output(unsigned gpio, int value)
|
|
|
|
-{
|
|
|
|
- unsigned long flags;
|
|
|
|
-
|
|
|
|
- if (!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))) {
|
|
|
|
- gpio_error(gpio);
|
|
|
|
- return -EINVAL;
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- local_irq_save_hw(flags);
|
|
|
|
- gpio_bankb[gpio_bank(gpio)]->inen &= ~gpio_bit(gpio);
|
|
|
|
-
|
|
|
|
- if (value)
|
|
|
|
- gpio_bankb[gpio_bank(gpio)]->data_set = gpio_bit(gpio);
|
|
|
|
- else
|
|
|
|
- gpio_bankb[gpio_bank(gpio)]->data_clear = gpio_bit(gpio);
|
|
|
|
-
|
|
|
|
- gpio_bankb[gpio_bank(gpio)]->dir |= gpio_bit(gpio);
|
|
|
|
- AWA_DUMMY_READ(dir);
|
|
|
|
- local_irq_restore_hw(flags);
|
|
|
|
-
|
|
|
|
- return 0;
|
|
|
|
-}
|
|
|
|
-EXPORT_SYMBOL(bfin_gpio_direction_output);
|
|
|
|
-
|
|
|
|
/* If we are booting from SPI and our board lacks a strong enough pull up,
|
|
/* If we are booting from SPI and our board lacks a strong enough pull up,
|
|
* the core can reset and execute the bootrom faster than the resistor can
|
|
* the core can reset and execute the bootrom faster than the resistor can
|
|
* pull the signal logically high. To work around this (common) error in
|
|
* pull the signal logically high. To work around this (common) error in
|
|
@@ -1299,23 +1179,15 @@ EXPORT_SYMBOL(bfin_gpio_direction_output);
|
|
* lives here as we need to force all the GPIO states w/out going through
|
|
* lives here as we need to force all the GPIO states w/out going through
|
|
* BUG() checks and such.
|
|
* BUG() checks and such.
|
|
*/
|
|
*/
|
|
-void bfin_gpio_reset_spi0_ssel1(void)
|
|
|
|
|
|
+void bfin_reset_boot_spi_cs(unsigned short pin)
|
|
{
|
|
{
|
|
- u16 gpio = P_IDENT(P_SPI0_SSEL1);
|
|
|
|
-
|
|
|
|
|
|
+ unsigned short gpio = P_IDENT(pin);
|
|
port_setup(gpio, GPIO_USAGE);
|
|
port_setup(gpio, GPIO_USAGE);
|
|
- gpio_bankb[gpio_bank(gpio)]->data_set = gpio_bit(gpio);
|
|
|
|
|
|
+ gpio_array[gpio_bank(gpio)]->data_set = gpio_bit(gpio);
|
|
AWA_DUMMY_READ(data_set);
|
|
AWA_DUMMY_READ(data_set);
|
|
udelay(1);
|
|
udelay(1);
|
|
}
|
|
}
|
|
|
|
|
|
-void bfin_gpio_irq_prepare(unsigned gpio)
|
|
|
|
-{
|
|
|
|
- port_setup(gpio, GPIO_USAGE);
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
-#endif /*BF548_FAMILY */
|
|
|
|
-
|
|
|
|
#if defined(CONFIG_PROC_FS)
|
|
#if defined(CONFIG_PROC_FS)
|
|
static int gpio_proc_read(char *buf, char **start, off_t offset,
|
|
static int gpio_proc_read(char *buf, char **start, off_t offset,
|
|
int len, int *unused_i, void *unused_v)
|
|
int len, int *unused_i, void *unused_v)
|
|
@@ -1369,11 +1241,7 @@ int bfin_gpiolib_get_value(struct gpio_chip *chip, unsigned gpio)
|
|
|
|
|
|
void bfin_gpiolib_set_value(struct gpio_chip *chip, unsigned gpio, int value)
|
|
void bfin_gpiolib_set_value(struct gpio_chip *chip, unsigned gpio, int value)
|
|
{
|
|
{
|
|
-#ifdef BF548_FAMILY
|
|
|
|
return bfin_gpio_set_value(gpio, value);
|
|
return bfin_gpio_set_value(gpio, value);
|
|
-#else
|
|
|
|
- return set_gpio_data(gpio, value);
|
|
|
|
-#endif
|
|
|
|
}
|
|
}
|
|
|
|
|
|
int bfin_gpiolib_gpio_request(struct gpio_chip *chip, unsigned gpio)
|
|
int bfin_gpiolib_gpio_request(struct gpio_chip *chip, unsigned gpio)
|