drivers/w1/masters/w1-gpio.c

Source file repositories/reference/linux-study-clean/drivers/w1/masters/w1-gpio.c

File Facts

System
Linux kernel
Corpus path
drivers/w1/masters/w1-gpio.c
Extension
.c
Size
3927 bytes
Lines
157
Domain
Driver Families
Bucket
drivers/w1
Inferred role
Driver Families: implementation source
Status
source implementation candidate

Why This File Exists

Repeatable hardware-adapter layer. Deep compatibility for every driver is out of scope; this atlas records patterns, probe lifecycles, bus glue, IRQ/DMA usage, and links back to core abstractions.

Dependency Surface

Detected Declarations

Annotated Snippet

struct w1_gpio_ddata {
	struct gpio_desc *gpiod;
	struct gpio_desc *pullup_gpiod;
	unsigned int pullup_duration;
};

static u8 w1_gpio_set_pullup(void *data, int delay)
{
	struct w1_gpio_ddata *ddata = data;

	if (delay) {
		ddata->pullup_duration = delay;
	} else {
		if (ddata->pullup_duration) {
			/*
			 * This will OVERRIDE open drain emulation and force-pull
			 * the line high for some time.
			 */
			gpiod_set_raw_value(ddata->gpiod, 1);
			msleep(ddata->pullup_duration);
			/*
			 * This will simply set the line as input since we are doing
			 * open drain emulation in the GPIO library.
			 */
			gpiod_set_value(ddata->gpiod, 1);
		}
		ddata->pullup_duration = 0;
	}

	return 0;
}

static void w1_gpio_write_bit(void *data, u8 bit)
{
	struct w1_gpio_ddata *ddata = data;

	gpiod_set_value(ddata->gpiod, bit);
}

static u8 w1_gpio_read_bit(void *data)
{
	struct w1_gpio_ddata *ddata = data;

	return gpiod_get_value(ddata->gpiod) ? 1 : 0;
}

static int w1_gpio_probe(struct platform_device *pdev)
{
	struct w1_bus_master *master;
	struct w1_gpio_ddata *ddata;
	struct device *dev = &pdev->dev;
	/* Enforce open drain mode by default */
	enum gpiod_flags gflags = GPIOD_OUT_LOW_OPEN_DRAIN;
	int err;

	ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
	if (!ddata)
		return -ENOMEM;

	/*
	 * This parameter means that something else than the gpiolib has
	 * already set the line into open drain mode, so we should just
	 * driver it high/low like we are in full control of the line and
	 * open drain will happen transparently.
	 */
	if (device_property_present(dev, "linux,open-drain"))
		gflags = GPIOD_OUT_LOW;

	master = devm_kzalloc(dev, sizeof(*master), GFP_KERNEL);
	if (!master)
		return -ENOMEM;

	ddata->gpiod = devm_gpiod_get_index(dev, NULL, 0, gflags);
	if (IS_ERR(ddata->gpiod))
		return dev_err_probe(dev, PTR_ERR(ddata->gpiod), "gpio_request (pin) failed\n");

	ddata->pullup_gpiod =
		devm_gpiod_get_index_optional(dev, NULL, 1, GPIOD_OUT_LOW);
	if (IS_ERR(ddata->pullup_gpiod))
		return dev_err_probe(dev, PTR_ERR(ddata->pullup_gpiod),
				     "gpio_request (ext_pullup_enable_pin) failed\n");

	master->data = ddata;
	master->read_bit = w1_gpio_read_bit;
	gpiod_direction_output(ddata->gpiod, 1);
	master->write_bit = w1_gpio_write_bit;

	/*
	 * If we are using open drain emulation from the GPIO library,
	 * we need to use this pullup function that hammers the line

Annotation

Implementation Notes