← Back to branch summary

~ubuntu-branches/ubuntu/saucy/u-boot/saucy

« back to all changes in this revision

Viewing changes to drivers/gpio/da8xx_gpio.c

  • Committer: Package Import Robot
  • Author(s): Clint Adams
  • Date: 2012-05-01 18:07:19 UTC
  • mfrom: (16.1.23 sid)
  • Revision ID: package-import@ubuntu.com-20120501180719-rjntk3287im4a0ns
Tags: 2012.04.01-1
* New upstream version.
  - Update mipsel-native-endianness.diff.
  - Update no-error-on-set-but-unused-variables.diff (partially merged).
  - Drop kirkwood_spi-irq_mask.diff (merged).
  - Drop kirkwood-disable-l2c.diff (merged).

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/gpio/da8xx_gpio.c
23
23
#include <common.h>
24
24
#include <asm/io.h>
25
25
#include <asm/gpio.h>
26
 
#include <asm/arch/gpio.h>
27
26
#include <asm/arch/hardware.h>
28
27
#include <asm/arch/davinci_misc.h>
29
28
 
181
180
        { pinmux(18), 8, 2 },
182
181
};
183
182
 
184
 
int gpio_request(int gp, const char *label)
185
 
{
186
 
        if (gp >= MAX_NUM_GPIOS)
187
 
                return -1;
188
 
 
189
 
        if (gpio_registry[gp].is_registered)
190
 
                return -1;
191
 
 
192
 
        gpio_registry[gp].is_registered = 1;
193
 
        strncpy(gpio_registry[gp].name, label, GPIO_NAME_SIZE);
194
 
        gpio_registry[gp].name[GPIO_NAME_SIZE - 1] = 0;
195
 
 
196
 
        davinci_configure_pin_mux(&gpio_pinmux[gp], 1);
197
 
 
198
 
        return 0;
199
 
}
200
 
 
201
 
void gpio_free(int gp)
202
 
{
203
 
        gpio_registry[gp].is_registered = 0;
204
 
}
205
 
 
206
 
void gpio_toggle_value(int gp)
207
 
{
208
 
        gpio_set_value(gp, !gpio_get_value(gp));
209
 
}
210
 
 
211
 
int gpio_direction_input(int gp)
212
 
{
213
 
        struct davinci_gpio *bank;
214
 
 
215
 
        bank = GPIO_BANK(gp);
216
 
        setbits_le32(&bank->dir, 1U << GPIO_BIT(gp));
217
 
        return 0;
218
 
}
219
 
 
220
 
int gpio_direction_output(int gp, int value)
221
 
{
222
 
        struct davinci_gpio *bank;
223
 
 
224
 
        bank = GPIO_BANK(gp);
225
 
        clrbits_le32(&bank->dir, 1U << GPIO_BIT(gp));
226
 
        gpio_set_value(gp, value);
227
 
        return 0;
228
 
}
229
 
 
230
 
int gpio_get_value(int gp)
 
183
int gpio_request(unsigned gpio, const char *label)
 
184
{
 
185
        if (gpio >= MAX_NUM_GPIOS)
 
186
                return -1;
 
187
 
 
188
        if (gpio_registry[gpio].is_registered)
 
189
                return -1;
 
190
 
 
191
        gpio_registry[gpio].is_registered = 1;
 
192
        strncpy(gpio_registry[gpio].name, label, GPIO_NAME_SIZE);
 
193
        gpio_registry[gpio].name[GPIO_NAME_SIZE - 1] = 0;
 
194
 
 
195
        davinci_configure_pin_mux(&gpio_pinmux[gpio], 1);
 
196
 
 
197
        return 0;
 
198
}
 
199
 
 
200
int gpio_free(unsigned gpio)
 
201
{
 
202
        if (gpio >= MAX_NUM_GPIOS)
 
203
                return -1;
 
204
 
 
205
        if (!gpio_registry[gpio].is_registered)
 
206
                return -1;
 
207
 
 
208
        gpio_registry[gpio].is_registered = 0;
 
209
        gpio_registry[gpio].name[0] = '\0';
 
210
        /* Do not configure as input or change pin mux here */
 
211
        return 0;
 
212
}
 
213
 
 
214
int gpio_direction_input(unsigned gpio)
 
215
{
 
216
        struct davinci_gpio *bank;
 
217
 
 
218
        bank = GPIO_BANK(gpio);
 
219
        setbits_le32(&bank->dir, 1U << GPIO_BIT(gpio));
 
220
        return 0;
 
221
}
 
222
 
 
223
int gpio_direction_output(unsigned gpio, int value)
 
224
{
 
225
        struct davinci_gpio *bank;
 
226
 
 
227
        bank = GPIO_BANK(gpio);
 
228
        clrbits_le32(&bank->dir, 1U << GPIO_BIT(gpio));
 
229
        gpio_set_value(gpio, value);
 
230
        return 0;
 
231
}
 
232
 
 
233
int gpio_get_value(unsigned gpio)
231
234
{
232
235
        struct davinci_gpio *bank;
233
236
        unsigned int ip;
234
237
 
235
 
        bank = GPIO_BANK(gp);
236
 
        ip = in_le32(&bank->in_data) & (1U << GPIO_BIT(gp));
 
238
        bank = GPIO_BANK(gpio);
 
239
        ip = in_le32(&bank->in_data) & (1U << GPIO_BIT(gpio));
237
240
        return ip ? 1 : 0;
238
241
}
239
242
 
240
 
void gpio_set_value(int gp, int value)
 
243
int gpio_set_value(unsigned gpio, int value)
241
244
{
242
245
        struct davinci_gpio *bank;
243
246
 
244
 
        bank = GPIO_BANK(gp);
 
247
        bank = GPIO_BANK(gpio);
245
248
 
246
249
        if (value)
247
 
                bank->set_data = 1U << GPIO_BIT(gp);
 
250
                bank->set_data = 1U << GPIO_BIT(gpio);
248
251
        else
249
 
                bank->clr_data = 1U << GPIO_BIT(gp);
 
252
                bank->clr_data = 1U << GPIO_BIT(gpio);
 
253
 
 
254
        return 0;
250
255
}
251
256
 
252
257
void gpio_info(void)
253
258
{
254
 
        int gp, dir, val;
 
259
        unsigned gpio, dir, val;
255
260
        struct davinci_gpio *bank;
256
261
 
257
 
        for (gp = 0; gp < MAX_NUM_GPIOS; ++gp) {
258
 
                bank = GPIO_BANK(gp);
259
 
                dir = in_le32(&bank->dir) & (1U << GPIO_BIT(gp));
260
 
                val = gpio_get_value(gp);
 
262
        for (gpio = 0; gpio < MAX_NUM_GPIOS; ++gpio) {
 
263
                bank = GPIO_BANK(gpio);
 
264
                dir = in_le32(&bank->dir) & (1U << GPIO_BIT(gpio));
 
265
                val = gpio_get_value(gpio);
261
266
 
262
267
                printf("% 4d: %s: %d [%c] %s\n",
263
 
                        gp, dir ? " in" : "out", val,
264
 
                        gpio_registry[gp].is_registered ? 'x' : ' ',
265
 
                        gpio_registry[gp].name);
 
268
                        gpio, dir ? " in" : "out", val,
 
269
                        gpio_registry[gpio].is_registered ? 'x' : ' ',
 
270
                        gpio_registry[gpio].name);
266
271
        }
267
272
}