Пример #1
0
static int set_gpiochip(void)
{
        gpiochip = gpiochip_find(LIRC_GPIO_ID_STRING, is_right_chip);

        if (!gpiochip)
                return -ENODEV;

        return 0;

}
Пример #2
0
static int bcm2835_spi_setup(struct spi_device *spi)
{
	int err;
	struct gpio_chip *chip;
	/*
	 * sanity checking the native-chipselects
	 */
	if (spi->mode & SPI_NO_CS)
		return 0;
	if (gpio_is_valid(spi->cs_gpio))
		return 0;
	if (spi->chip_select > 1) {
		/* error in the case of native CS requested with CS > 1
		 * officially there is a CS2, but it is not documented
		 * which GPIO is connected with that...
		 */
		dev_err(&spi->dev,
			"setup: only two native chip-selects are supported\n");
		return -EINVAL;
	}
	/* now translate native cs to GPIO */

	/* get the gpio chip for the base */
	chip = gpiochip_find("pinctrl-bcm2835", chip_match_name);
	if (!chip)
		return 0;

	/* and calculate the real CS */
	spi->cs_gpio = chip->base + 8 - spi->chip_select;

	/* and set up the "mode" and level */
	dev_info(&spi->dev, "setting up native-CS%i as GPIO %i\n",
		 spi->chip_select, spi->cs_gpio);

	/* set up GPIO as output and pull to the correct level */
	err = gpio_direction_output(spi->cs_gpio,
				    (spi->mode & SPI_CS_HIGH) ? 0 : 1);
	if (err) {
		dev_err(&spi->dev,
			"could not set CS%i gpio %i as output: %i",
			spi->chip_select, spi->cs_gpio, err);
		return err;
	}

	return 0;
}
Пример #3
0
static int gpio_calc_base(void)
{
	struct gpio_chip *gpiochip;
	int i;

	/* Iterate over all possible GPIOs until we find the first GPIO chip, matching the base */
	for (i = 0 ; i < ARCH_NR_GPIOS; i++){
		gpiochip = gpiochip_find(&i, gpiochip_match);
		if (gpiochip) {
			  /* This is the first GPIO chip, we will use it as a global base even
			   * if there exist more gpiochips */ 
			  printk(KERN_INFO LIRC_DRIVER_NAME 
				  ": Found GPIO chip, label = %s, base = %d\n", gpiochip->label, i);
			  return i;
		}
	}

	return 0;
}
Пример #4
0
static struct gpio_desc *acpi_get_gpiod(char *path, int pin)
{
    struct gpio_chip *chip;
    acpi_handle handle;
    acpi_status status;

    status = acpi_get_handle(NULL, path, &handle);
    if (ACPI_FAILURE(status))
        return ERR_PTR(-ENODEV);

    chip = gpiochip_find(handle, acpi_gpiochip_find);
    if (!chip)
        return ERR_PTR(-ENODEV);

    if (pin < 0 || pin > chip->ngpio)
        return ERR_PTR(-EINVAL);

    return gpio_to_desc(chip->base + pin);
}
Пример #5
0
int tilt_sensor_init(void)
{
    int result;

    result = register_chrdev(64, "tilt_sensor", &tilt_sensor_fops);

    if (result < 0)
    {
        printk("register_chrdev() : faild.\n");
        return result;
    }

    printk("register_chrdev() : successful.\n");

    gpiochip = gpiochip_find("bcm2708_gpio", is_right_chip);

    if (!gpiochip) {
        printk("gpiochip_find() failed...\n");
        return -ENODEV;
    }

    if (gpio_request(gpio_s1, DRIVER_NAME " ir/in"))
    {
        printk(KERN_ALERT DRIVER_NAME
               ": cant claim gpio pin %d\n", gpio_s1);
        gpio_free(gpio_s1);
        return -ENODEV;
    }

    if (gpio_request(gpio_s2, DRIVER_NAME " ir/in"))
    {
        printk(KERN_ALERT DRIVER_NAME
               ": cant claim gpio pin %d\n", gpio_s2);
        gpio_free(gpio_s2);
        return -ENODEV;
    }

    printk("gpiochip_find() successful!\n");
    gpiochip->direction_input(gpiochip, gpio_s1);
    gpiochip->direction_input(gpiochip, gpio_s2);

    return 0;
}
Пример #6
0
static void mx35_3ds_lcd_set_power(
				struct plat_lcd_data *pd, unsigned int power)
{
	struct gpio_chip *chip;

	if (!gpio_is_valid(lcd_power_gpio)) {
		chip = gpiochip_find(
				"mc9s08dz60", mc9s08dz60_gpiochip_match);
		if (chip) {
			lcd_power_gpio =
				chip->base + GPIO_MC9S08DZ60_LCD_ENABLE;
			if (gpio_request(lcd_power_gpio, "lcd_power") < 0) {
				pr_err("error: gpio already requested!\n");
				lcd_power_gpio = -ENXIO;
			}
		} else {
			pr_err("error: didn't find mc9s08dz60 gpio chip\n");
		}
	}

	if (gpio_is_valid(lcd_power_gpio))
		gpio_set_value_cansleep(lcd_power_gpio, power);
}
Пример #7
0
//内核加载后的初始化函数.
static int __init pi_led_init(void)
{
   struct device *dev;
   int major; //自动分配主设备号
   major = alloc_chrdev_region(&pi_led_devno,0,1,DRIVER_NAME);
   //register_chrdev 注册字符设备使系统知道有LED这个模块在.
   
   cdev_init(&pi_led_class_dev, &pi_led_dev_fops);
   major = cdev_add(&pi_led_class_dev,pi_led_devno,1);
   //注册class
   pi_led_class = class_create(THIS_MODULE,DRIVER_NAME);
   
   dev = device_create(pi_led_class ,NULL,pi_led_devno,NULL,DRIVER_NAME);
   
   gpiochip = gpiochip_find("bcm2708_gpio", is_right_chip);
   gpiochip->direction_output(gpiochip, led_pin, 1);
   gpiochip->set(gpiochip, led_pin, 1);
   msleep(500);
   gpiochip->set(gpiochip, led_pin, 0);
   interval = 500;
   printk("pi led init ok!\n");
   return 0;
}
Пример #8
0
static int init_port(void)
{
	int i, nlow, nhigh, ret;
	struct device_node *node;

	node = lirc_rpi_dev->dev.of_node;

	gpiochip = gpiochip_find("bcm2708_gpio", is_right_chip);
	/*
	 * Because of the lack of a setpull function, only support
	 * pinctrl-bcm2835 if using device tree.
	*/
	if (!gpiochip && node)
		gpiochip = gpiochip_find("pinctrl-bcm2835", is_right_chip);

	if (!gpiochip) {
		pr_err(LIRC_DRIVER_NAME ": gpio chip not found!\n");
		return -ENODEV;
	}

	if (node) {
		struct device_node *pins_node;

		pins_node = of_parse_phandle(node, "pinctrl-0", 0);
		if (!pins_node) {
			printk(KERN_ERR LIRC_DRIVER_NAME
			       ": pinctrl settings not found!\n");
			ret = -EINVAL;
			goto exit_init_port;
		}

		read_pin_settings(pins_node);

		of_property_read_u32(node, "rpi,sense", &sense);

		read_bool_property(node, "rpi,softcarrier", &softcarrier);

		read_bool_property(node, "rpi,invert", &invert);

		read_bool_property(node, "rpi,debug", &debug);

	}
	else
	{
		for(i=0;i<INPUT_PIN_NUM;i++) {
			if (gpio_in_pin[i] >= BCM2708_NR_GPIOS ||
		    	gpio_out_pin >= BCM2708_NR_GPIOS) {
				ret = -EINVAL;
				printk(KERN_ERR LIRC_DRIVER_NAME
			    	   ": invalid GPIO pin(s) specified!\n");
				goto exit_init_port;
			}


			if (gpio_request(gpio_in_pin[i], LIRC_DRIVER_NAME " ir/in")) {
				printk(KERN_ALERT LIRC_DRIVER_NAME
			    	   ": cant claim gpio pin %d\n", gpio_in_pin[i]);
				ret = -ENODEV;
				goto exit_gpio_free_out_pin;
			}

			bcm2708_gpio_setpull(gpiochip, gpio_in_pin[i], gpio_in_pull);
			gpiochip->direction_input(gpiochip, gpio_in_pin[i]);
		}
		
		if (gpio_request(gpio_out_pin, LIRC_DRIVER_NAME " ir/out")) {
			printk(KERN_ALERT LIRC_DRIVER_NAME
		   	    ": cant claim gpio pin %d\n", gpio_out_pin);
			ret = -ENODEV;
			goto exit_init_port;
		}
		gpiochip->direction_output(gpiochip, gpio_out_pin, 1);
	}

	gpiochip->set(gpiochip, gpio_out_pin, invert);

	for (i=0; i<INPUT_PIN_NUM; i++){
		irq_num[i] = gpiochip->to_irq(gpiochip, gpio_in_pin[i]);
		printk(KERN_INFO LIRC_DRIVER_NAME "to_irq %d   gpio_num  %d \n", irq_num[i], gpio_in_pin[i]);
	}
	printk(KERN_INFO LIRC_DRIVER_NAME "gpio_out  %d \n",gpio_out_pin);
	/* if pin is high, then this must be an active low receiver. */
	if (sense == -1) {
		/* wait 1/2 sec for the power supply */
		msleep(500);

		/*
		 * probe 9 times every 0.04s, collect "votes" for
		 * active high/low
		 */
		nlow = 0;
		nhigh = 0;
		for (i = 0; i < 9; i++) {
			if (gpiochip->get(gpiochip, gpio_in_pin[0]))
				nlow++;
			else
				nhigh++;
			msleep(40);
		}
		sense = (nlow >= nhigh ? 1 : 0);
		printk(KERN_INFO LIRC_DRIVER_NAME
		       ": auto-detected active %s receiver on GPIO pin %d\n",
		       sense ? "low" : "high", gpio_in_pin[0]);
	} else {
		printk(KERN_INFO LIRC_DRIVER_NAME
		       ": manually using active %s receiver on GPIO pin %d\n",
		       sense ? "low" : "high", gpio_in_pin[0]);
	}

	return 0;

	exit_gpio_free_out_pin:
	gpio_free(gpio_out_pin);

	exit_init_port:
	return ret;
}
Пример #9
0
/**
 * of_get_named_gpio_flags() - Get a GPIO number and flags to use with GPIO API
 * @np:		device node to get GPIO from
 * @propname:	property name containing gpio specifier(s)
 * @index:	index of the GPIO
 * @flags:	a flags pointer to fill in
 *
 * Returns GPIO number to use with Linux generic GPIO API, or one of the errno
 * value on the error condition. If @flags is not NULL the function also fills
 * in flags for the GPIO.
 */
int of_get_named_gpio_flags(struct device_node *np, const char *propname,
			   int index, enum of_gpio_flags *flags)
{
	/* Return -EPROBE_DEFER to support probe() functions to be called
	 * later when the GPIO actually becomes available
	 */
	struct gg_data gg_data = { .flags = flags, .out_gpio = -EPROBE_DEFER };
	int ret;

	/* .of_xlate might decide to not fill in the flags, so clear it. */
	if (flags)
		*flags = 0;

	ret = of_parse_phandle_with_args(np, propname, "#gpio-cells", index,
					 &gg_data.gpiospec);
	if (ret) {
		pr_debug("%s: can't parse gpios property of node '%s[%d]'\n",
			__func__, np->full_name, index);
		return ret;
	}

	gpiochip_find(&gg_data, of_gpiochip_find_and_xlate);

	of_node_put(gg_data.gpiospec.np);
	pr_debug("%s exited with status %d\n", __func__, gg_data.out_gpio);
	return gg_data.out_gpio;
}
EXPORT_SYMBOL(of_get_named_gpio_flags);

/**
 * of_gpio_simple_xlate - translate gpio_spec to the GPIO number and flags
 * @gc:		pointer to the gpio_chip structure
 * @np:		device node of the GPIO chip
 * @gpio_spec:	gpio specifier as found in the device tree
 * @flags:	a flags pointer to fill in
 *
 * This is simple translation function, suitable for the most 1:1 mapped
 * gpio chips. This function performs only one sanity check: whether gpio
 * is less than ngpios (that is specified in the gpio_chip).
 */
int of_gpio_simple_xlate(struct gpio_chip *gc,
			 const struct of_phandle_args *gpiospec, u32 *flags)
{
	/*
	 * We're discouraging gpio_cells < 2, since that way you'll have to
	 * write your own xlate function (that will have to retrive the GPIO
	 * number and the flags from a single gpio cell -- this is possible,
	 * but not recommended).
	 */
	if (gc->of_gpio_n_cells < 2) {
		WARN_ON(1);
		return -EINVAL;
	}

	if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells))
		return -EINVAL;

	if (gpiospec->args[0] >= gc->ngpio)
		return -EINVAL;

	if (flags)
		*flags = gpiospec->args[1];

	return gpiospec->args[0];
}
EXPORT_SYMBOL(of_gpio_simple_xlate);

/**
 * of_mm_gpiochip_add - Add memory mapped GPIO chip (bank)
 * @np:		device node of the GPIO chip
 * @mm_gc:	pointer to the of_mm_gpio_chip allocated structure
 *
 * To use this function you should allocate and fill mm_gc with:
 *
 * 1) In the gpio_chip structure:
 *    - all the callbacks
 *    - of_gpio_n_cells
 *    - of_xlate callback (optional)
 *
 * 3) In the of_mm_gpio_chip structure:
 *    - save_regs callback (optional)
 *
 * If succeeded, this function will map bank's memory and will
 * do all necessary work for you. Then you'll able to use .regs
 * to manage GPIOs from the callbacks.
 */
int of_mm_gpiochip_add(struct device_node *np,
		       struct of_mm_gpio_chip *mm_gc)
{
	int ret = -ENOMEM;
	struct gpio_chip *gc = &mm_gc->gc;

	gc->label = kstrdup(np->full_name, GFP_KERNEL);
	if (!gc->label)
		goto err0;

	mm_gc->regs = of_iomap(np, 0);
	if (!mm_gc->regs)
		goto err1;

	gc->base = -1;

	if (mm_gc->save_regs)
		mm_gc->save_regs(mm_gc);

	mm_gc->gc.of_node = np;

	ret = gpiochip_add(gc);
	if (ret)
		goto err2;

	return 0;
err2:
	iounmap(mm_gc->regs);
err1:
	kfree(gc->label);
err0:
	pr_err("%s: GPIO chip registration failed with status %d\n",
	       np->full_name, ret);
	return ret;
}
Пример #10
0
static struct gpio_chip *of_find_gpiochip_by_xlate(
					struct of_phandle_args *gpiospec)
{
	return gpiochip_find(gpiospec, of_gpiochip_match_node_and_xlate);
}
Пример #11
0
struct gpio_chip *of_node_to_gpiochip(struct device_node *np)
{
	return gpiochip_find(np, of_gpiochip_is_match);
}
Пример #12
0
/**
 * of_get_named_gpio_flags() - Get a GPIO number and flags to use with GPIO API
 * @np:		device node to get GPIO from
 * @propname:	property name containing gpio specifier(s)
 * @index:	index of the GPIO
 * @flags:	a flags pointer to fill in
 *
 * Returns GPIO number to use with Linux generic GPIO API, or one of the errno
 * value on the error condition. If @flags is not NULL the function also fills
 * in flags for the GPIO.
 */
int of_get_named_gpio_flags(struct device_node *np, const char *propname,
                           int index, enum of_gpio_flags *flags)
{
	/* Return -EPROBE_DEFER to support probe() functions to be called
	 * later when the GPIO actually becomes available
	 */
	struct gg_data gg_data = { .flags = flags, .out_gpio = -EPROBE_DEFER };
	int ret;

	/* .of_xlate might decide to not fill in the flags, so clear it. */
	if (flags)
		*flags = 0;

	ret = of_parse_phandle_with_args(np, propname, "#gpio-cells", index,
					 &gg_data.gpiospec);
	if (ret) {
		pr_debug("%s: can't parse gpios property\n", __func__);
		return ret;
	}

	gpiochip_find(&gg_data, of_gpiochip_find_and_xlate);

	of_node_put(gg_data.gpiospec.np);
	pr_debug("%s exited with status %d\n", __func__, gg_data.out_gpio);
	return gg_data.out_gpio;
}
EXPORT_SYMBOL(of_get_named_gpio_flags);

/**
 * of_gpio_named_count - Count GPIOs for a device
 * @np:		device node to count GPIOs for
 * @propname:	property name containing gpio specifier(s)
 *
 * The function returns the count of GPIOs specified for a node.
 *
 * Note that the empty GPIO specifiers counts too. For example,
 *
 * gpios = <0
 *          &pio1 1 2
 *          0
 *          &pio2 3 4>;
 *
 * defines four GPIOs (so this function will return 4), two of which
 * are not specified.
 */
unsigned int of_gpio_named_count(struct device_node *np, const char* propname)
{
	unsigned int cnt = 0;

	do {
		int ret;

		ret = of_parse_phandle_with_args(np, propname, "#gpio-cells",
						 cnt, NULL);
		/* A hole in the gpios = <> counts anyway. */
		if (ret < 0 && ret != -EEXIST)
			break;
	} while (++cnt);

	return cnt;
}
Пример #13
0
__init int engine_init(void){
	int ret;

	printk (KERN_INFO ENGINE_DRIVER_NAME ": init\n") ;

	gpiochip = gpiochip_find("bcm2708_gpio", is_right_chip);
	if (!gpiochip)
		return -ENODEV;

	if (gpio_request(A1_PIN, ENGINE_DRIVER_NAME "A1_PIN")) {
		printk(KERN_ALERT ENGINE_DRIVER_NAME
				": cant claim gpio pin %d\n", A1_PIN);
		ret = -ENODEV;
		goto exitA1;
	}
	if (gpio_request(A2_PIN, ENGINE_DRIVER_NAME "A2_PIN")) {
		printk(KERN_ALERT ENGINE_DRIVER_NAME
				": cant claim gpio pin %d\n", A2_PIN);
		ret = -ENODEV;
		goto exitA2;
	}
	if (gpio_request(B1_PIN, ENGINE_DRIVER_NAME "B1_PIN")) {
		printk(KERN_ALERT ENGINE_DRIVER_NAME
				": cant claim gpio pin %d\n", B1_PIN);
		ret = -ENODEV;
		goto exitB1;
	}
	if (gpio_request(B2_PIN, ENGINE_DRIVER_NAME "B2_PIN")) {
		printk(KERN_ALERT ENGINE_DRIVER_NAME
				": cant claim gpio pin %d\n", B2_PIN);
		ret = -ENODEV;
		goto exitB2;
	}
	printk(KERN_INFO ENGINE_DRIVER_NAME ": got all pins.\n");

	gpiochip->direction_output(gpiochip, A1_PIN, 1);
	gpiochip->set(gpiochip, A1_PIN, 1);
	gpiochip->direction_output(gpiochip, A2_PIN, 1);
	gpiochip->set(gpiochip, A2_PIN, 1);
	gpiochip->direction_output(gpiochip, B1_PIN, 1);
	gpiochip->set(gpiochip, B1_PIN, 1);
	gpiochip->direction_output(gpiochip, B1_PIN, 1);
	gpiochip->set(gpiochip, B2_PIN, 1);

	alloc_chrdev_region(&deviceMajMin, 0, 1, DEVICE_NAME);
	printk (KERN_INFO ENGINE_DRIVER_NAME ": major: %d\n", MAJOR(deviceMajMin));

	class = class_create(THIS_MODULE, DEVICE_NAME);
	cdev_init(&cdev, &fops);
	cdev.owner = THIS_MODULE;
	cdev_add(&cdev, deviceMajMin, 1);
	device_create(class, NULL, deviceMajMin, NULL, DEVICE_NAME);

	hrtimer_init(&step_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
	step_timer.function = &hrtimer_routine;
	run_timer(steptime);

	return 0;
exitB2:
	gpio_free(B1_PIN);
exitB1:
	gpio_free(A2_PIN);
exitA2:
	gpio_free(A1_PIN);
exitA1:
	return ret;

}