2018-07-11 05:39:10 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2018-07-11 05:39:11 -06:00
|
|
|
/* Copyright (C) 2018 Google, Inc. */
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
#include "gasket.h"
|
|
|
|
|
#include "gasket_ioctl.h"
|
|
|
|
|
#include "gasket_constants.h"
|
|
|
|
|
#include "gasket_core.h"
|
|
|
|
|
#include "gasket_interrupt.h"
|
|
|
|
|
#include "gasket_page_table.h"
|
2018-07-19 21:49:19 -06:00
|
|
|
#include <linux/compiler.h>
|
2018-07-26 21:07:31 -06:00
|
|
|
#include <linux/device.h>
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
#include <linux/fs.h>
|
|
|
|
|
#include <linux/uaccess.h>
|
|
|
|
|
|
|
|
|
|
#ifdef GASKET_KERNEL_TRACE_SUPPORT
|
|
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
|
#include <trace/events/gasket_ioctl.h>
|
|
|
|
|
#else
|
|
|
|
|
#define trace_gasket_ioctl_entry(x, ...)
|
|
|
|
|
#define trace_gasket_ioctl_exit(x)
|
|
|
|
|
#define trace_gasket_ioctl_integer_data(x)
|
|
|
|
|
#define trace_gasket_ioctl_eventfd_data(x, ...)
|
|
|
|
|
#define trace_gasket_ioctl_page_table_data(x, ...)
|
|
|
|
|
#define trace_gasket_ioctl_config_coherent_allocator(x, ...)
|
|
|
|
|
#endif
|
|
|
|
|
|
2018-07-29 13:36:40 -06:00
|
|
|
/* Associate an eventfd with an interrupt. */
|
2018-07-19 21:49:20 -06:00
|
|
|
static int gasket_set_event_fd(struct gasket_dev *gasket_dev,
|
|
|
|
|
struct gasket_interrupt_eventfd __user *argp)
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
{
|
|
|
|
|
struct gasket_interrupt_eventfd die;
|
|
|
|
|
|
2018-07-19 21:49:20 -06:00
|
|
|
if (copy_from_user(&die, argp, sizeof(struct gasket_interrupt_eventfd)))
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
trace_gasket_ioctl_eventfd_data(die.interrupt, die.event_fd);
|
|
|
|
|
|
|
|
|
|
return gasket_interrupt_set_eventfd(
|
|
|
|
|
gasket_dev->interrupt_data, die.interrupt, die.event_fd);
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-29 13:36:40 -06:00
|
|
|
/* Read the size of the page table. */
|
2018-07-19 21:49:20 -06:00
|
|
|
static int gasket_read_page_table_size(
|
|
|
|
|
struct gasket_dev *gasket_dev,
|
|
|
|
|
struct gasket_page_table_ioctl __user *argp)
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
struct gasket_page_table_ioctl ibuf;
|
|
|
|
|
|
2018-07-19 21:49:20 -06:00
|
|
|
if (copy_from_user(&ibuf, argp, sizeof(struct gasket_page_table_ioctl)))
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
if (ibuf.page_table_index >= gasket_dev->num_page_tables)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
ibuf.size = gasket_page_table_num_entries(
|
|
|
|
|
gasket_dev->page_table[ibuf.page_table_index]);
|
|
|
|
|
|
|
|
|
|
trace_gasket_ioctl_page_table_data(
|
|
|
|
|
ibuf.page_table_index, ibuf.size, ibuf.host_address,
|
|
|
|
|
ibuf.device_address);
|
|
|
|
|
|
2018-07-19 21:49:20 -06:00
|
|
|
if (copy_to_user(argp, &ibuf, sizeof(ibuf)))
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-29 13:36:40 -06:00
|
|
|
/* Read the size of the simple page table. */
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
static int gasket_read_simple_page_table_size(
|
2018-07-19 21:49:20 -06:00
|
|
|
struct gasket_dev *gasket_dev,
|
|
|
|
|
struct gasket_page_table_ioctl __user *argp)
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
struct gasket_page_table_ioctl ibuf;
|
|
|
|
|
|
2018-07-19 21:49:20 -06:00
|
|
|
if (copy_from_user(&ibuf, argp, sizeof(struct gasket_page_table_ioctl)))
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
if (ibuf.page_table_index >= gasket_dev->num_page_tables)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2018-07-31 14:24:40 -06:00
|
|
|
ibuf.size =
|
|
|
|
|
gasket_page_table_num_simple_entries(gasket_dev->page_table[ibuf.page_table_index]);
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
|
2018-07-31 14:24:40 -06:00
|
|
|
trace_gasket_ioctl_page_table_data(ibuf.page_table_index, ibuf.size,
|
|
|
|
|
ibuf.host_address,
|
|
|
|
|
ibuf.device_address);
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
|
2018-07-19 21:49:20 -06:00
|
|
|
if (copy_to_user(argp, &ibuf, sizeof(ibuf)))
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-29 13:36:40 -06:00
|
|
|
/* Set the boundary between the simple and extended page tables. */
|
2018-07-19 21:49:20 -06:00
|
|
|
static int gasket_partition_page_table(
|
|
|
|
|
struct gasket_dev *gasket_dev,
|
|
|
|
|
struct gasket_page_table_ioctl __user *argp)
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
struct gasket_page_table_ioctl ibuf;
|
|
|
|
|
uint max_page_table_size;
|
|
|
|
|
|
2018-07-19 21:49:20 -06:00
|
|
|
if (copy_from_user(&ibuf, argp, sizeof(struct gasket_page_table_ioctl)))
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
trace_gasket_ioctl_page_table_data(
|
|
|
|
|
ibuf.page_table_index, ibuf.size, ibuf.host_address,
|
|
|
|
|
ibuf.device_address);
|
|
|
|
|
|
|
|
|
|
if (ibuf.page_table_index >= gasket_dev->num_page_tables)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
max_page_table_size = gasket_page_table_max_size(
|
|
|
|
|
gasket_dev->page_table[ibuf.page_table_index]);
|
|
|
|
|
|
|
|
|
|
if (ibuf.size > max_page_table_size) {
|
2018-07-26 21:07:31 -06:00
|
|
|
dev_dbg(gasket_dev->dev,
|
|
|
|
|
"Partition request 0x%llx too large, max is 0x%x\n",
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
ibuf.size, max_page_table_size);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mutex_lock(&gasket_dev->mutex);
|
|
|
|
|
|
|
|
|
|
ret = gasket_page_table_partition(
|
|
|
|
|
gasket_dev->page_table[ibuf.page_table_index], ibuf.size);
|
|
|
|
|
mutex_unlock(&gasket_dev->mutex);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-29 13:36:40 -06:00
|
|
|
/* Map a userspace buffer to a device virtual address. */
|
2018-07-19 21:49:20 -06:00
|
|
|
static int gasket_map_buffers(struct gasket_dev *gasket_dev,
|
|
|
|
|
struct gasket_page_table_ioctl __user *argp)
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
{
|
|
|
|
|
struct gasket_page_table_ioctl ibuf;
|
|
|
|
|
|
2018-07-19 21:49:20 -06:00
|
|
|
if (copy_from_user(&ibuf, argp, sizeof(struct gasket_page_table_ioctl)))
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
2018-07-31 14:24:40 -06:00
|
|
|
trace_gasket_ioctl_page_table_data(ibuf.page_table_index, ibuf.size,
|
|
|
|
|
ibuf.host_address,
|
|
|
|
|
ibuf.device_address);
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
|
|
|
|
|
if (ibuf.page_table_index >= gasket_dev->num_page_tables)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2018-07-31 14:24:40 -06:00
|
|
|
if (gasket_page_table_are_addrs_bad(gasket_dev->page_table[ibuf.page_table_index],
|
|
|
|
|
ibuf.host_address,
|
|
|
|
|
ibuf.device_address, ibuf.size))
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2018-07-31 14:24:40 -06:00
|
|
|
return gasket_page_table_map(gasket_dev->page_table[ibuf.page_table_index],
|
|
|
|
|
ibuf.host_address, ibuf.device_address,
|
|
|
|
|
ibuf.size / PAGE_SIZE);
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
}
|
|
|
|
|
|
2018-07-29 13:36:40 -06:00
|
|
|
/* Unmap a userspace buffer from a device virtual address. */
|
2018-07-19 21:49:20 -06:00
|
|
|
static int gasket_unmap_buffers(struct gasket_dev *gasket_dev,
|
|
|
|
|
struct gasket_page_table_ioctl __user *argp)
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
{
|
|
|
|
|
struct gasket_page_table_ioctl ibuf;
|
|
|
|
|
|
2018-07-19 21:49:20 -06:00
|
|
|
if (copy_from_user(&ibuf, argp, sizeof(struct gasket_page_table_ioctl)))
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
2018-07-31 14:24:40 -06:00
|
|
|
trace_gasket_ioctl_page_table_data(ibuf.page_table_index, ibuf.size,
|
|
|
|
|
ibuf.host_address,
|
|
|
|
|
ibuf.device_address);
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
|
|
|
|
|
if (ibuf.page_table_index >= gasket_dev->num_page_tables)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2018-07-31 14:24:40 -06:00
|
|
|
if (gasket_page_table_is_dev_addr_bad(gasket_dev->page_table[ibuf.page_table_index],
|
|
|
|
|
ibuf.device_address, ibuf.size))
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
gasket_page_table_unmap(gasket_dev->page_table[ibuf.page_table_index],
|
|
|
|
|
ibuf.device_address, ibuf.size / PAGE_SIZE);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2018-07-29 13:36:40 -06:00
|
|
|
* Reserve structures for coherent allocation, and allocate or free the
|
|
|
|
|
* corresponding memory.
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
*/
|
|
|
|
|
static int gasket_config_coherent_allocator(
|
2018-07-19 21:49:20 -06:00
|
|
|
struct gasket_dev *gasket_dev,
|
|
|
|
|
struct gasket_coherent_alloc_config_ioctl __user *argp)
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
struct gasket_coherent_alloc_config_ioctl ibuf;
|
|
|
|
|
|
2018-07-19 21:49:20 -06:00
|
|
|
if (copy_from_user(&ibuf, argp,
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
sizeof(struct gasket_coherent_alloc_config_ioctl)))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2018-07-31 14:24:40 -06:00
|
|
|
trace_gasket_ioctl_config_coherent_allocator(ibuf.enable, ibuf.size,
|
|
|
|
|
ibuf.dma_address);
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
|
|
|
|
|
if (ibuf.page_table_index >= gasket_dev->num_page_tables)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
2018-07-19 21:49:05 -06:00
|
|
|
if (ibuf.size > PAGE_SIZE * MAX_NUM_COHERENT_PAGES)
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
if (ibuf.enable == 0) {
|
2018-07-31 14:24:40 -06:00
|
|
|
ret = gasket_free_coherent_memory(gasket_dev, ibuf.size,
|
|
|
|
|
ibuf.dma_address,
|
|
|
|
|
ibuf.page_table_index);
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
} else {
|
2018-07-31 14:24:40 -06:00
|
|
|
ret = gasket_alloc_coherent_memory(gasket_dev, ibuf.size,
|
|
|
|
|
&ibuf.dma_address,
|
|
|
|
|
ibuf.page_table_index);
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
}
|
2018-07-21 07:34:57 -06:00
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
2018-07-19 21:49:20 -06:00
|
|
|
if (copy_to_user(argp, &ibuf, sizeof(ibuf)))
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
2018-07-21 07:34:57 -06:00
|
|
|
return 0;
|
drivers/staging: Gasket driver framework + Apex driver
The Gasket (Google ASIC Software, Kernel Extensions, and Tools) kernel
framework is a generic, flexible system that supports thin kernel
drivers. Gasket kernel drivers are expected to handle opening and
closing devices, mmap'ing BAR space as requested, a small selection of
ioctls, and handling page table translation (covered below). Any other
functions should be handled by userspace code.
The Gasket common module is not enough to run a device. In order to
customize the Gasket code for a given piece of hardware, a device
specific module must be created. At a minimum, this module must define a
struct gasket_driver_desc containing the device-specific data for use by
the framework; in addition, the module must declare an __init function
that calls gasket_register_device with the module's gasket_driver_desc
struct. Finally, the driver must define an exit function that calls
gasket_unregister_device with the module's gasket_driver_desc struct.
One of the core assumptions of the Gasket framework is that precisely
one process is allowed to have an open write handle to the device node
at any given time. (That process may, once it has one write handle, open
any number of additional write handles.) This is accomplished by
tracking open and close data for each driver instance.
Signed-off-by: Rob Springer <rspringer@google.com>
Signed-off-by: John Joseph <jnjoseph@google.com>
Signed-off-by: Simon Que <sque@chromium.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-06-29 20:49:38 -06:00
|
|
|
}
|
2018-07-31 14:24:35 -06:00
|
|
|
|
|
|
|
|
/* Check permissions for Gasket ioctls. */
|
|
|
|
|
static bool gasket_ioctl_check_permissions(struct file *filp, uint cmd)
|
|
|
|
|
{
|
|
|
|
|
bool alive;
|
|
|
|
|
bool read, write;
|
|
|
|
|
struct gasket_dev *gasket_dev = (struct gasket_dev *)filp->private_data;
|
|
|
|
|
|
|
|
|
|
alive = (gasket_dev->status == GASKET_STATUS_ALIVE);
|
|
|
|
|
if (!alive)
|
|
|
|
|
dev_dbg(gasket_dev->dev, "%s alive %d status %d\n",
|
|
|
|
|
__func__, alive, gasket_dev->status);
|
|
|
|
|
|
|
|
|
|
read = !!(filp->f_mode & FMODE_READ);
|
|
|
|
|
write = !!(filp->f_mode & FMODE_WRITE);
|
|
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
|
case GASKET_IOCTL_RESET:
|
|
|
|
|
case GASKET_IOCTL_CLEAR_INTERRUPT_COUNTS:
|
|
|
|
|
return write;
|
|
|
|
|
|
|
|
|
|
case GASKET_IOCTL_PAGE_TABLE_SIZE:
|
|
|
|
|
case GASKET_IOCTL_SIMPLE_PAGE_TABLE_SIZE:
|
|
|
|
|
case GASKET_IOCTL_NUMBER_PAGE_TABLES:
|
|
|
|
|
return read;
|
|
|
|
|
|
|
|
|
|
case GASKET_IOCTL_PARTITION_PAGE_TABLE:
|
|
|
|
|
case GASKET_IOCTL_CONFIG_COHERENT_ALLOCATOR:
|
|
|
|
|
return alive && write;
|
|
|
|
|
|
|
|
|
|
case GASKET_IOCTL_MAP_BUFFER:
|
|
|
|
|
case GASKET_IOCTL_UNMAP_BUFFER:
|
|
|
|
|
return alive && write;
|
|
|
|
|
|
|
|
|
|
case GASKET_IOCTL_CLEAR_EVENTFD:
|
|
|
|
|
case GASKET_IOCTL_SET_EVENTFD:
|
|
|
|
|
return alive && write;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false; /* unknown permissions */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* standard ioctl dispatch function.
|
|
|
|
|
* @filp: File structure pointer describing this node usage session.
|
|
|
|
|
* @cmd: ioctl number to handle.
|
|
|
|
|
* @argp: ioctl-specific data pointer.
|
|
|
|
|
*
|
|
|
|
|
* Standard ioctl dispatcher; forwards operations to individual handlers.
|
|
|
|
|
*/
|
|
|
|
|
long gasket_handle_ioctl(struct file *filp, uint cmd, void __user *argp)
|
|
|
|
|
{
|
|
|
|
|
struct gasket_dev *gasket_dev;
|
|
|
|
|
unsigned long arg = (unsigned long)argp;
|
|
|
|
|
gasket_ioctl_permissions_cb_t ioctl_permissions_cb;
|
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
|
|
gasket_dev = (struct gasket_dev *)filp->private_data;
|
|
|
|
|
trace_gasket_ioctl_entry(gasket_dev->dev_info.name, cmd);
|
|
|
|
|
|
|
|
|
|
ioctl_permissions_cb = gasket_get_ioctl_permissions_cb(gasket_dev);
|
|
|
|
|
if (ioctl_permissions_cb) {
|
|
|
|
|
retval = ioctl_permissions_cb(filp, cmd, argp);
|
|
|
|
|
if (retval < 0) {
|
|
|
|
|
trace_gasket_ioctl_exit(retval);
|
|
|
|
|
return retval;
|
|
|
|
|
} else if (retval == 0) {
|
|
|
|
|
trace_gasket_ioctl_exit(-EPERM);
|
|
|
|
|
return -EPERM;
|
|
|
|
|
}
|
|
|
|
|
} else if (!gasket_ioctl_check_permissions(filp, cmd)) {
|
|
|
|
|
trace_gasket_ioctl_exit(-EPERM);
|
|
|
|
|
dev_dbg(gasket_dev->dev, "ioctl cmd=%x noperm\n", cmd);
|
|
|
|
|
return -EPERM;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Tracing happens in this switch statement for all ioctls with
|
|
|
|
|
* an integer argrument, but ioctls with a struct argument
|
|
|
|
|
* that needs copying and decoding, that tracing is done within
|
|
|
|
|
* the handler call.
|
|
|
|
|
*/
|
|
|
|
|
switch (cmd) {
|
|
|
|
|
case GASKET_IOCTL_RESET:
|
2018-08-02 02:42:43 -06:00
|
|
|
retval = gasket_reset(gasket_dev);
|
2018-07-31 14:24:35 -06:00
|
|
|
break;
|
|
|
|
|
case GASKET_IOCTL_SET_EVENTFD:
|
|
|
|
|
retval = gasket_set_event_fd(gasket_dev, argp);
|
|
|
|
|
break;
|
|
|
|
|
case GASKET_IOCTL_CLEAR_EVENTFD:
|
|
|
|
|
trace_gasket_ioctl_integer_data(arg);
|
2018-07-31 14:24:40 -06:00
|
|
|
retval =
|
|
|
|
|
gasket_interrupt_clear_eventfd(gasket_dev->interrupt_data,
|
|
|
|
|
(int)arg);
|
2018-07-31 14:24:35 -06:00
|
|
|
break;
|
|
|
|
|
case GASKET_IOCTL_PARTITION_PAGE_TABLE:
|
|
|
|
|
trace_gasket_ioctl_integer_data(arg);
|
|
|
|
|
retval = gasket_partition_page_table(gasket_dev, argp);
|
|
|
|
|
break;
|
|
|
|
|
case GASKET_IOCTL_NUMBER_PAGE_TABLES:
|
|
|
|
|
trace_gasket_ioctl_integer_data(gasket_dev->num_page_tables);
|
|
|
|
|
if (copy_to_user(argp, &gasket_dev->num_page_tables,
|
|
|
|
|
sizeof(uint64_t)))
|
|
|
|
|
retval = -EFAULT;
|
|
|
|
|
else
|
|
|
|
|
retval = 0;
|
|
|
|
|
break;
|
|
|
|
|
case GASKET_IOCTL_PAGE_TABLE_SIZE:
|
|
|
|
|
retval = gasket_read_page_table_size(gasket_dev, argp);
|
|
|
|
|
break;
|
|
|
|
|
case GASKET_IOCTL_SIMPLE_PAGE_TABLE_SIZE:
|
|
|
|
|
retval = gasket_read_simple_page_table_size(gasket_dev, argp);
|
|
|
|
|
break;
|
|
|
|
|
case GASKET_IOCTL_MAP_BUFFER:
|
|
|
|
|
retval = gasket_map_buffers(gasket_dev, argp);
|
|
|
|
|
break;
|
|
|
|
|
case GASKET_IOCTL_CONFIG_COHERENT_ALLOCATOR:
|
|
|
|
|
retval = gasket_config_coherent_allocator(gasket_dev, argp);
|
|
|
|
|
break;
|
|
|
|
|
case GASKET_IOCTL_UNMAP_BUFFER:
|
|
|
|
|
retval = gasket_unmap_buffers(gasket_dev, argp);
|
|
|
|
|
break;
|
|
|
|
|
case GASKET_IOCTL_CLEAR_INTERRUPT_COUNTS:
|
|
|
|
|
/* Clear interrupt counts doesn't take an arg, so use 0. */
|
|
|
|
|
trace_gasket_ioctl_integer_data(0);
|
|
|
|
|
retval = gasket_interrupt_reset_counts(gasket_dev);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
/* If we don't understand the ioctl, the best we can do is trace
|
|
|
|
|
* the arg.
|
|
|
|
|
*/
|
|
|
|
|
trace_gasket_ioctl_integer_data(arg);
|
|
|
|
|
dev_dbg(gasket_dev->dev,
|
|
|
|
|
"Unknown ioctl cmd=0x%x not caught by "
|
|
|
|
|
"gasket_is_supported_ioctl\n",
|
|
|
|
|
cmd);
|
|
|
|
|
retval = -EINVAL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
trace_gasket_ioctl_exit(retval);
|
|
|
|
|
return retval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Determines if an ioctl is part of the standard Gasket framework.
|
|
|
|
|
* @cmd: The ioctl number to handle.
|
|
|
|
|
*
|
|
|
|
|
* Returns 1 if the ioctl is supported and 0 otherwise.
|
|
|
|
|
*/
|
|
|
|
|
long gasket_is_supported_ioctl(uint cmd)
|
|
|
|
|
{
|
|
|
|
|
switch (cmd) {
|
|
|
|
|
case GASKET_IOCTL_RESET:
|
|
|
|
|
case GASKET_IOCTL_SET_EVENTFD:
|
|
|
|
|
case GASKET_IOCTL_CLEAR_EVENTFD:
|
|
|
|
|
case GASKET_IOCTL_PARTITION_PAGE_TABLE:
|
|
|
|
|
case GASKET_IOCTL_NUMBER_PAGE_TABLES:
|
|
|
|
|
case GASKET_IOCTL_PAGE_TABLE_SIZE:
|
|
|
|
|
case GASKET_IOCTL_SIMPLE_PAGE_TABLE_SIZE:
|
|
|
|
|
case GASKET_IOCTL_MAP_BUFFER:
|
|
|
|
|
case GASKET_IOCTL_UNMAP_BUFFER:
|
|
|
|
|
case GASKET_IOCTL_CLEAR_INTERRUPT_COUNTS:
|
|
|
|
|
case GASKET_IOCTL_CONFIG_COHERENT_ALLOCATOR:
|
|
|
|
|
return 1;
|
|
|
|
|
default:
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|