/* * GPIO tools - helpers library for the GPIO tools * * Copyright (C) 2015 Linus Walleij * Copyright (C) 2016 Bamvor Jian Zhang * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 as published by * the Free Software Foundation. */ #include #include #include #include #include #include #include #include #include #include "gpio-utils.h" #define COMSUMER "gpio-utils" /** * doc: Operation of gpio * * Provide the api of gpiochip for chardev interface. There are two * types of api. The first one provide as same function as each * ioctl, including request and release for lines of gpio, read/write * the value of gpio. If the user want to do lots of read and write of * lines of gpio, user should use this type of api. * * The second one provide the easy to use api for user. Each of the * following api will request gpio lines, do the operation and then * release these lines. */ /** * gpiotools_request_linehandle() - request gpio lines in a gpiochip * @device_name: The name of gpiochip without prefix "/dev/", * such as "gpiochip0" * @lines: An array desired lines, specified by offset * index for the associated GPIO device. * @nline: The number of lines to request. * @flag: The new flag for requsted gpio. Reference * "linux/gpio.h" for the meaning of flag. * @data: Default value will be set to gpio when flag is * GPIOHANDLE_REQUEST_OUTPUT. * @consumer_label: The name of consumer, such as "sysfs", * "powerkey". This is useful for other users to * know who is using. * * Request gpio lines through the ioctl provided by chardev. User * could call gpiotools_set_values() and gpiotools_get_values() to * read and write respectively through the returned fd. Call * gpiotools_release_linehandle() to release these lines after that. * * Return: On success return the fd; * On failure return the errno. */ int gpiotools_request_linehandle(const char *device_name, unsigned int *lines, unsigned int nlines, unsigned int flag, struct gpiohandle_data *data, const char *consumer_label) { struct gpiohandle_request req; char *chrdev_name; int fd; int i; int ret; ret = asprintf(&chrdev_name, "/dev/%s", device_name); if (ret < 0) return -ENOMEM; fd = open(chrdev_name, 0); if (fd == -1) { ret = -errno; fprintf(stderr, "Failed to open %s\n", chrdev_name); goto exit_close_error; } for (i = 0; i < nlines; i++) req.lineoffsets[i] = lines[i]; req.flags = flag; strcpy(req.consumer_label, consumer_label); req.lines = nlines; if (flag & GPIOHANDLE_REQUEST_OUTPUT) memcpy(req.default_values, data, sizeof(req.default_values)); ret = ioctl(fd, GPIO_GET_LINEHANDLE_IOCTL, &req); if (ret == -1) { ret = -errno; fprintf(stderr, "Failed to issue GET LINEHANDLE IOCTL (%d)\n", ret); } exit_close_error: if (close(fd) == -1) perror("Failed to close GPIO character device file"); free(chrdev_name); return ret < 0 ? ret : req.fd; } /** * gpiotools_set_values(): Set the value of gpio(s) * @fd: The fd returned by * gpiotools_request_linehandle(). * @data: The array of values want to set. * * Return: On success return 0; * On failure return the errno. */ int gpiotools_set_values(const int fd, struct gpiohandle_data *data) { int ret; ret = ioctl(fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, data); if (ret == -1) { ret = -errno; fprintf(stderr, "Failed to issue %s (%d)\n", "GPIOHANDLE_SET_LINE_VALUES_IOCTL", ret); } return ret; } /** * gpiotools_get_values(): Get the value of gpio(s) * @fd: The fd returned by * gpiotools_request_linehandle(). * @data: The array of values get from hardware. * * Return: On success return 0; * On failure return the errno. */ int gpiotools_get_values(const int fd, struct gpiohandle_data *data) { int ret; ret = ioctl(fd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, data); if (ret == -1) { ret = -errno; fprintf(stderr, "Failed to issue %s (%d)\n", "GPIOHANDLE_GET_LINE_VALUES_IOCTL", ret); } return ret; } /** * gpiotools_release_linehandle(): Release the line(s) of gpiochip * @fd: The fd returned by * gpiotools_request_linehandle(). * * Return: On success return 0; * On failure return the errno. */ int gpiotools_release_linehandle(const int fd) { int ret; ret = close(fd); if (ret == -1) { perror("Failed to close GPIO LINEHANDLE device file"); ret = -errno; } return ret; } /** * gpiotools_get(): Get value from specific line * @device_name: The name of gpiochip without prefix "/dev/", * such as "gpiochip0" * @line: number of line, such as 2. * * Return: On success return 0; * On failure return the errno. */ int gpiotools_get(const char *device_name, unsigned int line) { struct gpiohandle_data data; unsigned int lines[] = {line}; gpiotools_gets(device_name, lines, 1, &data); return data.values[0]; } /** * gpiotools_gets(): Get values from specific lines. * @device_name: The name of gpiochip without prefix "/dev/", * such as "gpiochip0". * @lines: An array desired lines, specified by offset * index for the associated GPIO device. * @nline: The number of lines to request. * @data: The array of values get from gpiochip. * * Return: On success return 0; * On failure return the errno. */ int gpiotools_gets(const char *device_name, unsigned int *lines, unsigned int nlines, struct gpiohandle_data *data) { int fd; int ret; int ret_close; ret = gpiotools_request_linehandle(device_name, lines, nlines, GPIOHANDLE_REQUEST_INPUT, data, COMSUMER); if (ret < 0) return ret; fd = ret; ret = gpiotools_get_values(fd, data); ret_close = gpiotools_release_linehandle(fd); return ret < 0 ? ret : ret_close; } /** * gpiotools_set(): Set value to specific line * @device_name: The name of gpiochip without prefix "/dev/", * such as "gpiochip0" * @line: number of line, such as 2. * @value: The value of gpio, must be 0(low) or 1(high). * * Return: On success return 0; * On failure return the errno. */ int gpiotools_set(const char *device_name, unsigned int line, unsigned int value) { struct gpiohandle_data data; unsigned int lines[] = {line}; data.values[0] = value; return gpiotools_sets(device_name, lines, 1, &data); } /** * gpiotools_sets(): Set values to specific lines. * @device_name: The name of gpiochip without prefix "/dev/", * such as "gpiochip0". * @lines: An array desired lines, specified by offset * index for the associated GPIO device. * @nline: The number of lines to request. * @data: The array of values set to gpiochip, must be * 0(low) or 1(high). * * Return: On success return 0; * On failure return the errno. */ int gpiotools_sets(const char *device_name, unsigned int *lines, unsigned int nlines, struct gpiohandle_data *data) { int ret; ret = gpiotools_request_linehandle(device_name, lines, nlines, GPIOHANDLE_REQUEST_OUTPUT, data, COMSUMER); if (ret < 0) return ret; return gpiotools_release_linehandle(ret); } ule+0x48/0xc0 blk_mq_freeze_queue_wait+0x94/0x120 blk_mq_queue_reinit_work+0xb8/0x180 blk_mq_queue_reinit_prepare+0x84/0xa0 cpuhp_invoke_callback+0x17c/0x600 cpuhp_up_callbacks+0x58/0x150 _cpu_up+0xf0/0x1c0 do_cpu_up+0x120/0x150 cpu_subsys_online+0x64/0xe0 device_online+0xb4/0x120 online_store+0xb4/0xc0 dev_attr_store+0x68/0xa0 sysfs_kf_write+0x80/0xb0 kernfs_fop_write+0x17c/0x250 __vfs_write+0x6c/0x1e0 vfs_write+0xd0/0x270 SyS_write+0x6c/0x110 system_call+0x38/0xe0 Examination of the queue showed a single reference (no PERCPU_COUNT_BIAS, and __PERCPU_REF_DEAD, __PERCPU_REF_ATOMIC set) and no requests. However, conditions at the time of the race are count of PERCPU_COUNT_BIAS + 0 and __PERCPU_REF_DEAD and __PERCPU_REF_ATOMIC set. The fix is to make the tryget routines use an actual boolean internally instead of the atomic long result truncated to a int. Fixes: e625305b3907 percpu-refcount: make percpu_ref based on longs instead of ints Link: https://bugzilla.kernel.org/show_bug.cgi?id=190751 Signed-off-by: Douglas Miller <dougmill@linux.vnet.ibm.com> Reviewed-by: Jens Axboe <axboe@fb.com> Signed-off-by: Tejun Heo <tj@kernel.org> Fixes: e625305b3907 ("percpu-refcount: make percpu_ref based on longs instead of ints") Cc: stable@vger.kernel.org # v3.18+
Diffstat (limited to 'sound/oss/README.FIRST')