staging: sep: move to misc: sep: to move to mainline
Subsystems (2)
PATCH 1/1 staging: sep: move to misc: sep: to move to mainline
--- drivers/misc/Kconfig | 1 + drivers/misc/Makefile | 1 + drivers/misc/sep/Kconfig | 10 + drivers/misc/sep/Makefile | 2 + drivers/misc/sep/TODO | 4 + drivers/misc/sep/sep_dev.h | 131 ++ drivers/misc/sep/sep_driver.c | 2928 ++++++++++++++++++++++++++++++ drivers/misc/sep/sep_driver_api.h | 215 +++ drivers/misc/sep/sep_driver_config.h | 243 +++ drivers/misc/sep/sep_driver_hw_defs.h | 233 +++ drivers/staging/Kconfig | 2 - drivers/staging/Makefile | 1 - drivers/staging/sep/Kconfig | 10 - drivers/staging/sep/Makefile | 2 - drivers/staging/sep/TODO | 4 - drivers/staging/sep/sep_dev.h | 131 -- drivers/staging/sep/sep_driver.c | 2928 ------------------------------ drivers/staging/sep/sep_driver_api.h | 215 --- drivers/staging/sep/sep_driver_config.h | 243 --- drivers/staging/sep/sep_driver_hw_defs.h | 233 --- 20 files changed, 3768 insertions(+), 3769 deletions(-) create mode 100644 drivers/misc/sep/Kconfig create mode 100644 drivers/misc/sep/Makefile create mode 100644 drivers/misc/sep/TODO create mode 100644 drivers/misc/sep/sep_dev.h create mode 100644 drivers/misc/sep/sep_driver.c create mode 100644 drivers/misc/sep/sep_driver_api.h create mode 100644 drivers/misc/sep/sep_driver_config.h create mode 100644 drivers/misc/sep/sep_driver_hw_defs.h delete mode 100644 drivers/staging/sep/Kconfig delete mode 100644 drivers/staging/sep/Makefile delete mode 100644 drivers/staging/sep/TODO delete mode 100644 drivers/staging/sep/sep_dev.h delete mode 100644 drivers/staging/sep/sep_driver.c delete mode 100644 drivers/staging/sep/sep_driver_api.h delete mode 100644 drivers/staging/sep/sep_driver_config.h delete mode 100644 drivers/staging/sep/sep_driver_hw_defs.h
drivers/misc/Kconfig +1 -0
@@ -481,5 +481,6 @@ source "drivers/misc/cb710/Kconfig" source "drivers/misc/iwmc3200top/Kconfig" source "drivers/misc/ti-st/Kconfig" source "drivers/misc/lis3lv02d/Kconfig" +source "drivers/misc/sep/Kconfig" endif # MISC_DEVICES
drivers/misc/Makefile +1 -0
@@ -44,3 +44,4 @@ obj-$(CONFIG_PCH_PHUB) += pch_phub.o obj-y += ti-st/ obj-$(CONFIG_AB8500_PWM) += ab8500-pwm.o obj-y += lis3lv02d/ +obj-$(CONFIG_DX_SEP) += sep/
drivers/misc/sep/Kconfig new file +10 -0
@@ -0,0 +1,10 @@ +config DX_SEP + tristate "Discretix SEP driver" + depends on PCI + help + Discretix SEP driver; used for the security processor subsystem + on bard the Intel Mobile Internet Device. + + The driver's name is sep_driver. + + If unsure, select N.
drivers/misc/sep/Makefile new file +2 -0
@@ -0,0 +1,2 @@ +obj-$(CONFIG_DX_SEP) := sep_driver.o +
drivers/misc/sep/TODO new file +4 -0
@@ -0,0 +1,4 @@ +Todo's so far (from Alan Cox) +- Check whether it can be plugged into any of the kernel crypto API + interfaces - Crypto API 'glue' is still not ready to submit +- Clean up un-needed debug prints - Started to work on this
drivers/misc/sep/sep_dev.h new file +131 -0
131 lines not on this page · raw message
drivers/misc/sep/sep_driver.c new file +2928 -0
2,843 lines not on this page · raw message
drivers/misc/sep/sep_driver_api.h new file +215 -0
215 lines not on this page · raw message
drivers/misc/sep/sep_driver_config.h new file +243 -0
243 lines not on this page · raw message
drivers/misc/sep/sep_driver_hw_defs.h new file +233 -0
233 lines not on this page · raw message
drivers/staging/sep/sep_dev.h deleted +0 -131
131 lines not on this page · raw message
drivers/staging/sep/sep_driver.c deleted +0 -2928
2,928 lines not on this page · raw message
drivers/staging/sep/sep_driver_api.h deleted +0 -215
215 lines not on this page · raw message
drivers/staging/sep/sep_driver_config.h deleted +0 -243
243 lines not on this page · raw message
drivers/staging/sep/sep_driver_hw_defs.h deleted +0 -233
233 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
1.7.0.4
Part of the diff is not shown here. View the raw message.
drivers/misc/sep/TODO line 4
Quoted 7 lines · Mark Allyn
drivers/misc/sep/TODO new file +4
-0@@ -0,0 +1,4 @@ +Todo's so far (from Alan Cox) +- Check whether it can be plugged into any of the kernel crypto API + interfaces - Crypto API 'glue' is still not ready to submit +- Clean up un-needed debug prints - Started to work on this
You copied over the TODO file? Why, shouldn't those be resolved first?
Also, can you send a git patch that does the rename so we can verify that nothing really did get changed?
I'll do a review of the code before accepting this as well, give me a week or so.
thanks,
greg k-h
Quoted 70 lines
From: [email protected] [mailto:[email protected]] On Behalf Of Mark Allyn
Sent: Friday, April 22, 2011 1:51 PMSigned-off-by Mark Allyn <[email protected]>--- drivers/misc/Kconfig | 1 + drivers/misc/Makefile | 1 + drivers/misc/sep/Kconfig | 10 + drivers/misc/sep/Makefile | 2 + drivers/misc/sep/TODO | 4 + drivers/misc/sep/sep_dev.h | 131 ++ drivers/misc/sep/sep_driver.c | 2928 ++++++++++++++++++++++++++++++ drivers/misc/sep/sep_driver_api.h | 215 +++ drivers/misc/sep/sep_driver_config.h | 243 +++ drivers/misc/sep/sep_driver_hw_defs.h | 233 +++ drivers/staging/Kconfig | 2 - drivers/staging/Makefile | 1 - drivers/staging/sep/Kconfig | 10 - drivers/staging/sep/Makefile | 2 - drivers/staging/sep/TODO | 4 - drivers/staging/sep/sep_dev.h | 131 -- drivers/staging/sep/sep_driver.c | 2928 ------------------------------ drivers/staging/sep/sep_driver_api.h | 215 --- drivers/staging/sep/sep_driver_config.h | 243 --- drivers/staging/sep/sep_driver_hw_defs.h | 233 --- 20 files changed, 3768 insertions(+), 3769 deletions(-) create mode 100644 drivers/misc/sep/Kconfig create mode 100644 drivers/misc/sep/Makefile create mode 100644 drivers/misc/sep/TODO create mode 100644 drivers/misc/sep/sep_dev.h create mode 100644 drivers/misc/sep/sep_driver.c create mode 100644 drivers/misc/sep/sep_driver_api.h create mode 100644 drivers/misc/sep/sep_driver_config.h create mode 100644 drivers/misc/sep/sep_driver_hw_defs.h delete mode 100644 drivers/staging/sep/Kconfig delete mode 100644 drivers/staging/sep/Makefile delete mode 100644 drivers/staging/sep/TODO delete mode 100644 drivers/staging/sep/sep_dev.h delete mode 100644 drivers/staging/sep/sep_driver.c delete mode 100644 drivers/staging/sep/sep_driver_api.h delete mode 100644 drivers/staging/sep/sep_driver_config.h delete mode 100644 drivers/staging/sep/sep_driver_hw_defs.hdrivers/misc/Kconfig +1
-0@@ -481,5 +481,6 @@ source "drivers/misc/cb710/Kconfig" source "drivers/misc/iwmc3200top/Kconfig" source "drivers/misc/ti-st/Kconfig" source "drivers/misc/lis3lv02d/Kconfig" +source "drivers/misc/sep/Kconfig" endif # MISC_DEVICESdrivers/misc/Makefile +1
-0@@ -44,3 +44,4 @@ obj-$(CONFIG_PCH_PHUB) += pch_phub.o obj-y += ti-st/ obj-$(CONFIG_AB8500_PWM) += ab8500-pwm.o obj-y += lis3lv02d/ +obj-$(CONFIG_DX_SEP) += sep/drivers/misc/sep/Kconfig new file +0
-0
drivers/misc/sep/Kconfig line 6
Quoted 6 lines
drivers/misc/sep/Kconfig new file +6
-0@@ -0,0 +1,10 @@ +config DX_SEP + tristate "Discretix SEP driver" + depends on PCI + help + Discretix SEP driver; used for the security processor subsystem + on bard the Intel Mobile Internet Device.
"on bard" -> "onboard"
Quoted 28 lines
drivers/misc/sep/Kconfig new file +4
-0+ + The driver's name is sep_driver. + + If unsure, select N.drivers/misc/sep/Makefile new file +2
-0@@ -0,0 +1,2 @@ +obj-$(CONFIG_DX_SEP) := sep_driver.o +drivers/misc/sep/TODO new file +4
-0@@ -0,0 +1,4 @@ +Todo's so far (from Alan Cox) +- Check whether it can be plugged into any of the kernel crypto API + interfaces - Crypto API 'glue' is still not ready to submit +- Clean up un-needed debug prints - Started to work on thisdrivers/misc/sep/sep_dev.h new file +0
-0
drivers/misc/sep/sep_dev.h line 8
Quoted 8 lines
drivers/misc/sep/sep_dev.h new file +8
-0@@ -0,0 +1,131 @@ +#ifndef __SEP_DEV_H__ +#define __SEP_DEV_H__ + +/* +* +* sep_dev.h - Security Processor Device Structures +* +* Copyright(c) 2009,2010 Intel Corporation. All rights reserved.
2009-2011?
Quoted 9 lines
drivers/misc/sep/sep_dev.h new file +9
-0+* Contributions(c) 2009,2010 Discretix. All rights reserved. +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the Free +* Software Foundation; version 2 of the License. +* +* This program is distributed in the hope that it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
drivers/misc/sep/sep_dev.h line 27
Quoted 10 lines
drivers/misc/sep/sep_dev.h new file +10
-0+* more details. +* +* You should have received a copy of the GNU General Public License along with +* this program; if not, write to the Free Software Foundation, Inc., 59 +* Temple Place - Suite 330, Boston, MA 02111-1307, USA. +* +* CONTACTS: +* +* Mark Allyn [email protected] +* Jayant Mangalampalli [email protected]
Wouldn't it be better to put yourselves in MAINTAINERS instead of in the source files (easier to change if someone else becomes the maintainer)?
Quoted 38 lines
drivers/misc/sep/sep_dev.h new file +38
-0+* +* CHANGES +* 2010.09.14 upgrade to Medfield +*/ + +struct sep_device { +/* pointer to pci dev */ +struct pci_dev *pdev; + +/* character device file */ +struct cdev sep_cdev; +struct cdev sep_daemon_cdev; +struct cdev sep_singleton_cdev; + +/* devices (using misc dev) */ +struct miscdevice miscdev_sep; +struct miscdevice miscdev_singleton; +struct miscdevice miscdev_daemon; + +/* major / minor numbers of device */ +dev_t sep_devno; +dev_t sep_daemon_devno; +dev_t sep_singleton_devno; + +struct mutex sep_mutex; +struct mutex ioctl_mutex; +spinlock_t snd_rply_lck; + +/* flags to indicate use and lock status of sep */ +u32 pid_doing_transaction; +unsigned long in_use_flags; + +/* request daemon alread open */ +unsigned long request_daemon_open; + +/* 1 = Moorestown; 0 = Medfield */ +int mrst; +
drivers/misc/sep/sep_dev.h line 75
Quoted 10 lines
drivers/misc/sep/sep_dev.h new file +10
-0+/* address of the shared memory allocated during init for SEP driver +(coherent alloc) */ +dma_addr_t shared_bus; +size_t shared_size; +void *shared_addr; + +/* start address of the access to the SEP registers from driver */ +dma_addr_t reg_physical_addr; +dma_addr_t reg_physical_end; +void __iomem *reg_addr;
reg_base might be more descriptive
Quoted 10 lines
drivers/misc/sep/sep_dev.h new file +10
-0+ +/* wait queue head (event) of the driver */ +wait_queue_head_t event; +wait_queue_head_t event_request_daemon; +wait_queue_head_t event_mmap; + +struct sep_caller_id_entry + caller_id_table[SEP_CALLER_ID_TABLE_NUM_ENTRIES ]; + +/* access flag for singleton device */
drivers/misc/sep/sep_dev.h line 95
Quoted 10 lines
drivers/misc/sep/sep_dev.h new file +10
-0+unsigned long singleton_access_flag; + +/* transaction counter that coordinates the +transactions between SEP and HOST */ +unsigned long send_ct; +/* counter for the messages from sep */ +unsigned long reply_ct; +/* counter for the number of bytes allocated in the pool for the +current transaction */ +long data_pool_bytes_allocated;
'unsigned long'?
Quoted 4 lines
drivers/misc/sep/sep_dev.h new file +4
-0+ +u32 num_of_data_allocations; + +/* number of the lli tables created in the current transaction */
drivers/misc/sep/sep_dev.h line 109
Quoted 10 lines
drivers/misc/sep/sep_dev.h new file +10
-0+u32 num_lli_tables_created; + +/* number of data control blocks */ +u32 nr_dcb_creat; + +struct sep_dma_resource dma_res_arr[SEP_MAX_NUM_SYNC_DMA_OPS ]; + +}; + +static inline void sep_write_reg (struct sep_device *dev,int reg,u32 value)
Presumably reg can't be negative, so why not 'unsigned int' or u32 (presumably it also can't be >4GB)?
drivers/misc/sep/sep_dev.h line 115
Quoted 6 lines
drivers/misc/sep/sep_dev.h new file +6
-0+{ +void __iomem *addr = dev->reg_addr + reg; +writel (value, addr); +} + +static inline u32 sep_read_reg (struct sep_device *dev,int reg)
Ditto above.
drivers/misc/sep/sep_dev.h line 121
Quoted 6 lines
drivers/misc/sep/sep_dev.h new file +6
-0+{ +void __iomem *addr = dev->reg_addr + reg; +return readl (addr); +} + +/* wait for SRAM write complete(indirect write */
Missing closing paren
drivers/misc/sep/sep_dev.h line 127
Quoted 6 lines
drivers/misc/sep/sep_dev.h new file +6
-0+static inline void sep_wait_sram_write (struct sep_device *dev) +{ +u32 reg_val; +do { + reg_val =sep_read_reg (dev,HW_SRAM_DATA_READY_REG_ADDR ); + }while (!(reg_val &1 ));
IMHO, it would be clearer to define a bitfield for this reg and test the ready bit explicitly.
Quoted 81 lines
drivers/misc/sep/sep_dev.h new file +4
-0+} + + +#endif drivers/misc/sep/sep_driver.c new file +71
-0@@ -0,0 +1,2928 @@ +/* +* +* sep_driver.c - Security Processor Driver main group of functions +* +* Copyright(c) 2009,2010 Intel Corporation. All rights reserved. +* Contributions(c) 2009,2010 Discretix. All rights reserved. +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the Free +* Software Foundation; version 2 of the License. +* +* This program is distributed in the hope that it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +* more details. +* +* You should have received a copy of the GNU General Public License along with +* this program; if not, write to the Free Software Foundation, Inc., 59 +* Temple Place - Suite 330, Boston, MA 02111-1307, USA. +* +* CONTACTS: +* +* Mark Allyn [email protected] +* Jayant Mangalampalli [email protected] +* +* CHANGES: +* +* 2009.06.26 Initial publish +* 2010.09.14 Upgrade to Medfield +* +*/ +#include <linux/init.h> +#include <linux/module.h> +#include <linux/miscdevice.h> +#include <linux/fs.h> +#include <linux/cdev.h> +#include <linux/kdev_t.h> +#include <linux/mutex.h> +#include <linux/sched.h> +#include <linux/mm.h> +#include <linux/poll.h> +#include <linux/wait.h> +#include <linux/pci.h> +#include <linux/firmware.h> +#include <linux/slab.h> +#include <linux/ioctl.h> +#include <asm/current.h> +#include <linux/ioport.h> +#include <linux/io.h> +#include <linux/interrupt.h> +#include <linux/pagemap.h> +#include <asm/cacheflush.h> +#include <linux/sched.h> +#include <linux/delay.h> +#include <linux/jiffies.h> +#include <linux/rar_register.h> + +#include "sep_driver_hw_defs.h" +#include "sep_driver_config.h" +#include "sep_driver_api.h" +#include "sep_dev.h" + +/*---------------------------------------- +DEFINES +-----------------------------------------*/ + +#define SEP_RAR_IO_MEM_REGION_SIZE 0x40000 + +/*-------------------------------------------- +GLOBAL variables +--------------------------------------------*/
drivers/misc/sep/sep_driver.c line 81
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+ +/* Keep this a single static object for now to keep the conversion easy */ + +static struct sep_device *sep_dev; + +/** +* sep_dump_message - dump the message that is pending +* @sep: SEP device +*/ +static void sep_dump_message (struct sep_device *sep)
'sep' -> 'dev' for consistency
drivers/misc/sep/sep_driver.c line 85
Quoted 4 lines
drivers/misc/sep/sep_driver.c new file +4
-0+{ +int count; +u32 *p = sep->shared_addr; +for (count =0 ; count <12 *4 ; count +=4 )
Magic # (12)
'4' -> sizeof(u32)
Quoted 39 lines
drivers/misc/sep/sep_driver.c new file +39
-0+dev_dbg (&sep->pdev->dev,"Word %d of the message is %x\n" , + count, *p++); +} + +/** +* sep_map_and_alloc_shared_area - allocate shared block +* @sep: security processor +* @size: size of shared area +*/ +static int sep_map_and_alloc_shared_area (struct sep_device *sep) +{ + sep->shared_addr =dma_alloc_coherent (&sep->pdev->dev, + sep->shared_size, + &sep->shared_bus,GFP_KERNEL ); + +if (!sep->shared_addr) { +dev_warn (&sep->pdev->dev, +"shared memory dma_alloc_coherent failed\n" ); +return -ENOMEM ; + } +dev_dbg (&sep->pdev->dev, +"shared_addr %zx bytes @%p (bus %llx)\n" , + sep->shared_size, sep->shared_addr, + (unsigned long long )sep->shared_bus); +return 0 ; +} + +/** +* sep_unmap_and_free_shared_area - free shared block +* @sep: security processor +*/ +static void sep_unmap_and_free_shared_area (struct sep_device *sep) +{ +dma_free_coherent (&sep->pdev->dev, sep->shared_size, + sep->shared_addr, sep->shared_bus); +} + +/** +* sep_shared_bus_to_virt - convert bus/virt addresses
drivers/misc/sep/sep_driver.c line 134
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+* @sep: pointer to struct sep_device +* @bus_address: address to convert +* +* Returns virtual address inside the shared area according +* to the bus address. +*/ +static void *sep_shared_bus_to_virt (struct sep_device *sep, +dma_addr_t bus_address) +{ +return sep->shared_addr + (bus_address - sep->shared_bus);
It would be good to check that (bus_address - sep->shared_bus) < shared_size
drivers/misc/sep/sep_driver.c line 144
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+} + +/** +* open function for the singleton driver +* @inode_ptr struct inode * +* @file_ptr struct file * +* +* Called when the user opens the singleton device interface +*/ +static int sep_singleton_open (struct inode *inode_ptr,struct file *file_ptr)
'file_ptr' -> 'filp' for consistency with other fns
drivers/misc/sep/sep_driver.c line 152
Quoted 8 lines
drivers/misc/sep/sep_driver.c new file +8
-0+{ +struct sep_device *sep; + +/* +* Get the SEP device structure and use it for the +* private_data field in filp for other methods +*/ + sep = sep_dev;
Why do you need a local var (sep)?
drivers/misc/sep/sep_driver.c line 157
Quoted 5 lines
drivers/misc/sep/sep_driver.c new file +5
-0+ + file_ptr->private_data = sep; + +if (test_and_set_bit (0 , &sep->singleton_access_flag)) +return -EBUSY ;
Shouldn't you test before you assign private_data?
Quoted 12 lines
drivers/misc/sep/sep_driver.c new file +12
-0+return 0 ; +} + +/** +* sep_open - device open method +* @inode: inode of SEP device +* @filp: file handle to SEP device +* +* Open method for the SEP device. Called when userspace opens +* the SEP device node. +* +* Returns zero on success otherwise an error code.
drivers/misc/sep/sep_driver.c line 179
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+*/ +static int sep_open (struct inode *inode,struct file *filp) +{ +struct sep_device *sep; + +/* +* Get the SEP device structure and use it for the +* private_data field in filp for other methods +*/ + sep = sep_dev;
Ditto above.
Quoted 27 lines
drivers/misc/sep/sep_driver.c new file +27
-0+ filp->private_data = sep; + +/* Anyone can open; locking takes place at transaction level */ +return 0 ; +} + +/** +* sep_singleton_release - close a SEP singleton device +* @inode: inode of SEP device +* @filp: file handle being closed +* +* Called on the final close of a SEP device. As the open protects against +* multiple simultaenous opens that means this method is called when the +* final reference to the open handle is dropped. +*/ +static int sep_singleton_release (struct inode *inode,struct file *filp) +{ +struct sep_device *sep = filp->private_data; + +clear_bit (0 , &sep->singleton_access_flag); +return 0 ; +} + +/** +* sep_request_daemonopen - request daemon open method +* @inode: inode of SEP device +* @filp: file handle to SEP device
drivers/misc/sep/sep_driver.c line 216
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+* +* Open method for the SEP request daemon. Called when +* request daemon in userspace opens the SEP device node. +* +* Returns zero on success otherwise an error code. +*/ +static int sep_request_daemon_open (struct inode *inode,struct file *filp) +{ +struct sep_device *sep = sep_dev; +int error =0 ;
'error' var not needed.
drivers/misc/sep/sep_driver.c line 222
Quoted 6 lines
drivers/misc/sep/sep_driver.c new file +6
-0+ + filp->private_data = sep; + +/* There is supposed to be only one request daemon */ +if (test_and_set_bit (0 , &sep->request_daemon_open)) + error = -EBUSY ;
Test before assign
drivers/misc/sep/sep_driver.c line 235
Quoted 13 lines
drivers/misc/sep/sep_driver.c new file +13
-0+return error; +} + +/** +* sep_request_daemon_release - close a SEP daemon +* @inode: inode of SEP device +* @filp: file handle being closed +* +* Called on the final close of a SEP daemon. +*/ +static int sep_request_daemon_release (struct inode *inode,struct file *filp) +{ +struct sep_device *sep = filp->private_data;
Test sep for NULL.
Quoted 4 lines
drivers/misc/sep/sep_driver.c new file +4
-0+ +dev_dbg (&sep->pdev->dev,"Request daemon release for pid %d\n" , + current->pid); +
drivers/misc/sep/sep_driver.c line 249
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+/* Clear the request_daemon_open flag */ +clear_bit (0 , &sep->request_daemon_open); +return 0 ; +} + +/** +* sep_req_daemon_send_reply_command_handler - poke the SEP +* @sep: struct sep_device * +* +* This function raises interrupt to SEPm that signals that is has a
"SEPm" -> "SEP"?
Quoted 6 lines
drivers/misc/sep/sep_driver.c new file +6
-0+* new command from HOST +*/ +static int sep_req_daemon_send_reply_command_handler (struct sep_device *sep) +{ +unsigned long lck_flags; +
drivers/misc/sep/sep_driver.c line 265
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+sep_dump_message (sep); + +/* Counters are lockable region */ +spin_lock_irqsave (&sep->snd_rply_lck, lck_flags); + sep->send_ct++; + sep->reply_ct++; + +/* Send the interrupt to SEP */ +sep_write_reg (sep,HW_HOST_HOST_SEP_GPR2_REG_ADDR , sep->send_ct); + sep->send_ct++;
Why increment twice?
Quoted 6 lines
drivers/misc/sep/sep_driver.c new file +6
-0+ +spin_unlock_irqrestore (&sep->snd_rply_lck, lck_flags); + +dev_dbg (&sep->pdev->dev, +"sep_req_daemon_send_reply send_ct %lx reply_ct %lx\n" , + sep->send_ct, sep->reply_ct);
drivers/misc/sep/sep_driver.c line 281
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+ +return 0 ; +} + + +/** +* sep_free_dma_table_data_handler - free DMA table +* @sep: pointere to struct sep_device +* +* Handles the request to free DMA table for synchronic actions
+ * Handles the request to free DMA table for synchronous actions
drivers/misc/sep/sep_driver.c line 286
Quoted 5 lines
drivers/misc/sep/sep_driver.c new file +5
-0+*/ +static int sep_free_dma_table_data_handler (struct sep_device *sep) +{ +int count; +int dcb_counter;
Both 'unsigned int'
Quoted 8 lines
drivers/misc/sep/sep_driver.c new file +8
-0+/* Pointer to the current dma_resource struct */ +struct sep_dma_resource *dma; + +for (dcb_counter =0 ; dcb_counter < sep->nr_dcb_creat; dcb_counter++) { + dma = &sep->dma_res_arr[dcb_counter]; + +/* Unmap and free input map array */ +if (dma->in_map_array) {
drivers/misc/sep/sep_driver.c line 304
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+for (count =0 ; count < dma->in_num_pages; count++) { +dma_unmap_page (&sep->pdev->dev, + dma->in_map_array[count].dma_addr, + dma->in_map_array[count].size, +DMA_TO_DEVICE ); + } +kfree (dma->in_map_array); + } + +/* Unmap output map array, DON'T free it yet */
"DON'T free it yet" -- but you do
Quoted 48 lines
drivers/misc/sep/sep_driver.c new file +48
-0+if (dma->out_map_array) { +for (count =0 ; count < dma->out_num_pages; count++) { +dma_unmap_page (&sep->pdev->dev, + dma->out_map_array[count].dma_addr, + dma->out_map_array[count].size, +DMA_FROM_DEVICE ); + } +kfree (dma->out_map_array); + } + +/* Free page cache for output */ +if (dma->in_page_array) { +for (count =0 ; count < dma->in_num_pages; count++) { +flush_dcache_page (dma->in_page_array[count]); +page_cache_release (dma->in_page_array[count]); + } +kfree (dma->in_page_array); + } + +if (dma->out_page_array) { +for (count =0 ; count < dma->out_num_pages; count++) { +if (!PageReserved (dma->out_page_array[count])) +SetPageDirty (dma->out_page_array[count]); +flush_dcache_page (dma->out_page_array[count]); +page_cache_release (dma->out_page_array[count]); + } +kfree (dma->out_page_array); + } + +/* Reset all the values */ + dma->in_page_array =NULL ; + dma->out_page_array =NULL ; + dma->in_num_pages =0 ; + dma->out_num_pages =0 ; + dma->in_map_array =NULL ; + dma->out_map_array =NULL ; + dma->in_map_num_entries =0 ; + dma->out_map_num_entries =0 ; + } + + sep->nr_dcb_creat =0 ; + sep->num_lli_tables_created =0 ; + +return 0 ; +} + +/** +* sep_request_daemon_mmap - maps the shared area to user space
drivers/misc/sep/sep_driver.c line 362
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+* @filp: pointer to struct file +* @vma: pointer to vm_area_struct +* +* Called by the kernel when the daemon attempts an mmap() syscall +* using our handle. +*/ +static int sep_request_daemon_mmap (struct file *filp, +struct vm_area_struct *vma) +{ +struct sep_device *sep = filp->private_data;
Test for NULL
drivers/misc/sep/sep_driver.c line 364
Quoted 2 lines
drivers/misc/sep/sep_driver.c new file +2
-0+dma_addr_t bus_address; +int error =0 ;
'error' not needed
drivers/misc/sep/sep_driver.c line 368
Quoted 4 lines
drivers/misc/sep/sep_driver.c new file +4
-0+ +if ((vma->vm_end - vma->vm_start) >SEP_DRIVER_MMMAP_AREA_SIZE ) { + error = -EINVAL ; + goto end_function;
Just 'return -EINVAL;'
drivers/misc/sep/sep_driver.c line 379
Quoted 11 lines
drivers/misc/sep/sep_driver.c new file +11
-0+ } + +/* Get physical address */ + bus_address = sep->shared_bus; + +if (remap_pfn_range (vma, vma->vm_start, bus_address >>PAGE_SHIFT , + vma->vm_end - vma->vm_start, vma->vm_page_prot)) { + +dev_warn (&sep->pdev->dev,"remap_page_range failed\n" ); + error = -EAGAIN ; + goto end_function;
Ditto
Quoted 8 lines
drivers/misc/sep/sep_driver.c new file +8
-0+ } + +end_function: +return error; +} + +/** +* sep_request_daemon_poll - poll implementation
drivers/misc/sep/sep_driver.c line 397
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+* @sep: struct sep_device * for current SEP device +* @filp: struct file * for open file +* @wait: poll_table * for poll +* +* Called when our device is part of a poll() or select() syscall +*/ +static unsigned int sep_request_daemon_poll (struct file *filp, +poll_table *wait) +{ +u32 mask =0 ;
'mask' not needed
drivers/misc/sep/sep_driver.c line 401
Quoted 4 lines
drivers/misc/sep/sep_driver.c new file +4
-0+/* GPR2 register */ +u32 retval2; +unsigned long lck_flags; +struct sep_device *sep = filp->private_data;
Test for NULL
Quoted 7 lines
drivers/misc/sep/sep_driver.c new file +7
-0+ +poll_wait (filp, &sep->event_request_daemon, wait); + +dev_dbg (&sep->pdev->dev,"daemon poll: send_ct is %lx reply ct is %lx\n" , + sep->send_ct, sep->reply_ct); + +spin_lock_irqsave (&sep->snd_rply_lck, lck_flags);
drivers/misc/sep/sep_driver.c line 418
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+/* Check if the data is ready */ +if (sep->send_ct == sep->reply_ct) { +spin_unlock_irqrestore (&sep->snd_rply_lck, lck_flags); + + retval2 =sep_read_reg (sep,HW_HOST_SEP_HOST_GPR2_REG_ADDR ); +dev_dbg (&sep->pdev->dev, +"daemon poll: data check (GPR2) is %x\n" , retval2); + +/* Check if PRINT request */ +if ((retval2 >>30 ) &0x1 ) {
Magic #s (bitfield test would be better)
drivers/misc/sep/sep_driver.c line 421
Quoted 3 lines
drivers/misc/sep/sep_driver.c new file +3
-0+dev_dbg (&sep->pdev->dev,"daemon poll: PRINTF request in\n" ); + mask |=POLLIN ; + goto end_function;
'return POLLIN;'
drivers/misc/sep/sep_driver.c line 426
Quoted 5 lines
drivers/misc/sep/sep_driver.c new file +5
-0+ } +/* Check if NVS request */ +if (retval2 >>31 ) { +dev_dbg (&sep->pdev->dev,"daemon poll: NVS request in\n" ); + mask |=POLLPRI |POLLWRNORM ;
'return POLLPRI | POLLWRNORM;'
drivers/misc/sep/sep_driver.c line 432
Quoted 6 lines
drivers/misc/sep/sep_driver.c new file +6
-0+ } + }else { +spin_unlock_irqrestore (&sep->snd_rply_lck, lck_flags); +dev_dbg (&sep->pdev->dev, +"daemon poll: no reply received; returning 0\n" ); + mask =0 ;
'return 0;'
Quoted 5 lines
drivers/misc/sep/sep_driver.c new file +5
-0+ } +end_function: +return mask; +} +
drivers/misc/sep/sep_driver.c line 447
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+/** +* sep_release - close a SEP device +* @inode: inode of SEP device +* @filp: file handle being closed +* +* Called on the final close of a SEP device. +*/ +static int sep_release (struct inode *inode,struct file *filp) +{ +struct sep_device *sep = filp->private_data;
Test for NULL
drivers/misc/sep/sep_driver.c line 457
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+ +dev_dbg (&sep->pdev->dev,"Release for pid %d\n" , current->pid); + +mutex_lock (&sep->sep_mutex); +/* Is this the process that has a transaction open? +* If so, lets reset pid_doing_transaction to 0 and +* clear the in use flags, and then wake up sep_event +* so that other processes can do transactions +*/ +if (sep->pid_doing_transaction == current->pid) {
How are you dealing with pid re-use?
Quoted 12 lines
drivers/misc/sep/sep_driver.c new file +12
-0+clear_bit (SEP_MMAP_LOCK_BIT , &sep->in_use_flags); +clear_bit (SEP_SEND_MSG_LOCK_BIT , &sep->in_use_flags); +sep_free_dma_table_data_handler (sep); +wake_up (&sep->event); + sep->pid_doing_transaction =0 ; + } + +mutex_unlock (&sep->sep_mutex); +return 0 ; +} + +/**
drivers/misc/sep/sep_driver.c line 479
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+* sep_mmap - maps the shared area to user space +* @filp: pointer to struct file +* @vma: pointer to vm_area_struct +* +* Called on an mmap of our space via the normal SEP device +*/ +static int sep_mmap (struct file *filp,struct vm_area_struct *vma) +{ +dma_addr_t bus_addr; +struct sep_device *sep = filp->private_data;
Test for NULL--and ditto for all uses in rest of file
Quoted 19 lines
drivers/misc/sep/sep_driver.c new file +19
-0+unsigned long error =0 ; + +/* Set the transaction busy (own the device) */ +wait_event_interruptible (sep->event, +test_and_set_bit (SEP_MMAP_LOCK_BIT , + &sep->in_use_flags) ==0 ); + +if (signal_pending (current)) { + error = -EINTR ; + goto end_function_with_error; + } +/* +* The pid_doing_transaction indicates that this process +* now owns the facilities to performa a transaction with +* the SEP. While this process is performing a transaction, +* no other process who has the SEP device open can perform +* any transactions. This method allows more than one process +* to have the device open at any given time, which provides +* finer granularity for device utilization by multiple
drivers/misc/sep/sep_driver.c line 508
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+* processes. +*/ +mutex_lock (&sep->sep_mutex); + sep->pid_doing_transaction = current->pid; +mutex_unlock (&sep->sep_mutex); + +/* Zero the pools and the number of data pool alocation pointers */ + sep->data_pool_bytes_allocated =0 ; + sep->num_of_data_allocations =0 ; +
Just call sep_request_daemon_mmap() instead of duplicating its code
Quoted 38 lines
drivers/misc/sep/sep_driver.c new file +38
-0+/* +* Check that the size of the mapped range is as the size of the message +* shared area +*/ +if ((vma->vm_end - vma->vm_start) >SEP_DRIVER_MMMAP_AREA_SIZE ) { + error = -EINVAL ; + goto end_function_with_error; + } + +dev_dbg (&sep->pdev->dev,"shared_addr is %p\n" , sep->shared_addr); + +/* Get bus address */ + bus_addr = sep->shared_bus; + +if (remap_pfn_range (vma, vma->vm_start, bus_addr >>PAGE_SHIFT , + vma->vm_end - vma->vm_start, vma->vm_page_prot)) { +dev_warn (&sep->pdev->dev,"remap_page_range failed\n" ); + error = -EAGAIN ; + goto end_function_with_error; + } + goto end_function; + +end_function_with_error: +/* Clear the bit */ +clear_bit (SEP_MMAP_LOCK_BIT , &sep->in_use_flags); +mutex_lock (&sep->sep_mutex); + sep->pid_doing_transaction =0 ; +mutex_unlock (&sep->sep_mutex); + +/* Raise event for stuck contextes */ + +wake_up (&sep->event); + +end_function: +return error; +} + +/**
drivers/misc/sep/sep_driver.c line 556
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+* sep_poll - poll handler +* @filp: pointer to struct file +* @wait: pointer to poll_table +* +* Called by the OS when the kernel is asked to do a poll on +* a SEP file handle. +*/ +static unsigned int sep_poll (struct file *filp,poll_table *wait) +{ +u32 mask =0 ;
No need for 'mask' (and goto's)--just return the value
drivers/misc/sep/sep_driver.c line 566
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+u32 retval =0 ; +u32 retval2 =0 ; +unsigned long lck_flags; + +struct sep_device *sep = filp->private_data; + +/* Am I the process that owns the transaction? */ +mutex_lock (&sep->sep_mutex); +if (current->pid != sep->pid_doing_transaction) { +dev_dbg (&sep->pdev->dev,"poll; wrong pid\n" );
Does this need to be w/in the mutex?
Quoted 145 lines
drivers/misc/sep/sep_driver.c new file +145
-0+ mask =POLLERR ; +mutex_unlock (&sep->sep_mutex); + goto end_function; + } +mutex_unlock (&sep->sep_mutex); + +/* Check if send command or send_reply were activated previously */ +if (!test_bit (SEP_SEND_MSG_LOCK_BIT , &sep->in_use_flags)) { + mask =POLLERR ; + goto end_function; + } + +/* Add the event to the polling wait table */ +dev_dbg (&sep->pdev->dev,"poll: calling wait sep_event\n" ); + +poll_wait (filp, &sep->event, wait); + +dev_dbg (&sep->pdev->dev,"poll: send_ct is %lx reply ct is %lx\n" , + sep->send_ct, sep->reply_ct); + +/* Check if error occurred during poll */ + retval2 =sep_read_reg (sep,HW_HOST_SEP_HOST_GPR3_REG_ADDR ); +if (retval2 !=0x0 ) { +dev_warn (&sep->pdev->dev,"poll; poll error %x\n" , retval2); + mask |=POLLERR ; + goto end_function; + } + +spin_lock_irqsave (&sep->snd_rply_lck, lck_flags); + +if (sep->send_ct == sep->reply_ct) { +spin_unlock_irqrestore (&sep->snd_rply_lck, lck_flags); + retval =sep_read_reg (sep,HW_HOST_SEP_HOST_GPR2_REG_ADDR ); +dev_dbg (&sep->pdev->dev,"poll: data ready check (GPR2) %x\n" , + retval); + +/* Check if printf request */ +if ((retval >>30 ) &0x1 ) { +dev_dbg (&sep->pdev->dev,"poll: SEP printf request\n" ); +wake_up (&sep->event_request_daemon); + goto end_function; + } + +/* Check if the this is SEP reply or request */ +if (retval >>31 ) { +dev_dbg (&sep->pdev->dev,"poll: SEP request\n" ); +wake_up (&sep->event_request_daemon); + }else { +dev_dbg (&sep->pdev->dev,"poll: normal return\n" ); +/* In case it is again by send_reply_comand */ +clear_bit (SEP_SEND_MSG_LOCK_BIT , &sep->in_use_flags); +sep_dump_message (sep); +dev_dbg (&sep->pdev->dev, +"poll; SEP reply POLLIN | POLLRDNORM\n" ); + mask |=POLLIN |POLLRDNORM ; + } + }else { +spin_unlock_irqrestore (&sep->snd_rply_lck, lck_flags); +dev_dbg (&sep->pdev->dev, +"poll; no reply received; returning mask of 0\n" ); + mask =0 ; + } + +end_function: +return mask; +} + +/** +* sep_time_address - address in SEP memory of time +* @sep: SEP device we want the address from +* +* Return the address of the two dwords in memory used for time +* setting. +*/ +static u32 *sep_time_address (struct sep_device *sep) +{ +return sep->shared_addr +SEP_DRIVER_SYSTEM_TIME_MEMORY_OFFSET_IN_BYTES ; +} + +/** +* sep_set_time - set the SEP time +* @sep: the SEP we are setting the time for +* +* Calculates time and sets it at the predefined address. +* Called with the SEP mutex held. +*/ +static unsigned long sep_set_time (struct sep_device *sep) +{ +struct timeval time; +u32 *time_addr;/* Address of time as seen by the kernel */ + + +do_gettimeofday (&time); + +/* Set value in the SYSTEM MEMORY offset */ + time_addr =sep_time_address (sep); + + time_addr[0 ] =SEP_TIME_VAL_TOKEN ; + time_addr[1 ] = time.tv_sec; + +dev_dbg (&sep->pdev->dev,"time.tv_sec is %lu\n" , time.tv_sec); +dev_dbg (&sep->pdev->dev,"time_addr is %p\n" , time_addr); +dev_dbg (&sep->pdev->dev,"sep->shared_addr is %p\n" , sep->shared_addr); + +return time.tv_sec; +} + +/** +* sep_set_caller_id_handler - insert caller id entry +* @sep: SEP device +* @arg: pointer to struct caller_id_struct +* +* Inserts the data into the caller id table. Note that this function +* falls under the ioctl lock +*/ +static int sep_set_caller_id_handler (struct sep_device *sep,unsigned long arg) +{ +void __user *hash; +int error =0 ; +int i; +struct caller_id_struct command_args; + +for (i =0 ; i <SEP_CALLER_ID_TABLE_NUM_ENTRIES ; i++) { +if (sep->caller_id_table[i].pid ==0 ) +break ; + } + +if (i ==SEP_CALLER_ID_TABLE_NUM_ENTRIES ) { +dev_dbg (&sep->pdev->dev,"no more caller id entries left\n" ); +dev_dbg (&sep->pdev->dev,"maximum number is %d\n" , +SEP_CALLER_ID_TABLE_NUM_ENTRIES ); + error = -EUSERS ; + goto end_function; + } + +/* Copy the data */ +if (copy_from_user (&command_args, (void __user *)arg, +sizeof (command_args))) { + error = -EFAULT ; + goto end_function; + } + + hash = (void __user *)(unsigned long )command_args.callerIdAddress; + +if (!command_args.pid || !command_args.callerIdSizeInBytes) {
drivers/misc/sep/sep_driver.c line 721
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+ error = -EINVAL ; + goto end_function; + } + +dev_dbg (&sep->pdev->dev,"pid is %x\n" , command_args.pid); +dev_dbg (&sep->pdev->dev,"callerIdSizeInBytes is %x\n" , + command_args.callerIdSizeInBytes); + +if (command_args.callerIdSizeInBytes > +SEP_CALLER_ID_HASH_SIZE_IN_BYTES ) {
Is it legal to have a smaller hash than SEP_CALLER_ID_HASH_SIZE_IN_BYTES? If so, since you don't store the size, how will SEP know what the real size is? If it is not legal, then you should enforce that command_args.callerIdSizeInBytes == SEP_CALLER_ID_HASH_SIZE_IN_BYTES.
drivers/misc/sep/sep_driver.c line 726
Quoted 5 lines
drivers/misc/sep/sep_driver.c new file +5
-0+ error = -EMSGSIZE ; + goto end_function; + } + + sep->caller_id_table[i].pid = command_args.pid;
Do you really trust the userspace caller to give you its pid?
drivers/misc/sep/sep_driver.c line 730
Quoted 4 lines
drivers/misc/sep/sep_driver.c new file +4
-0+ +if (copy_from_user (sep->caller_id_table[i].callerIdHash, + hash, command_args.callerIdSizeInBytes)) + error = -EFAULT ;
You should 0 sep->caller_id_table[i].pid when the copy fails (or better, don't set pid until after the copy succeeds).
Shouldn't you 0 the end of callerIdHash (SEP_CALLER_ID_HASH_SIZE_IN_BYTES - command_args.callerIdSizeInBytes)?
Quoted 9 lines
drivers/misc/sep/sep_driver.c new file +9
-0+end_function: +return error; +} + +/** +* sep_set_current_caller_id - set the caller id +* @sep: pointer to struct_sep_device +* +* Set the caller ID (if it exists) to the SEP. Note that this
drivers/misc/sep/sep_driver.c line 749
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+* function falls under the ioctl lock +*/ +static int sep_set_current_caller_id (struct sep_device *sep) +{ +int i; +u32 *hash_buf_ptr; + +/* Zero the previous value */ +memset (sep->shared_addr +SEP_CALLER_ID_OFFSET_BYTES , +0 ,SEP_CALLER_ID_HASH_SIZE_IN_BYTES );
Why?
drivers/misc/sep/sep_driver.c line 760
Quoted 11 lines
drivers/misc/sep/sep_driver.c new file +11
-0+ +for (i =0 ; i <SEP_CALLER_ID_TABLE_NUM_ENTRIES ; i++) { +if (sep->caller_id_table[i].pid == current->pid) { +dev_dbg (&sep->pdev->dev,"Caller Id found\n" ); + +memcpy (sep->shared_addr +SEP_CALLER_ID_OFFSET_BYTES , + (void *)(sep->caller_id_table[i].callerIdHash), +SEP_CALLER_ID_HASH_SIZE_IN_BYTES ); +break ; + } + }
How are you guaranteeing that the current caller (current->pid) is always in the array?
drivers/misc/sep/sep_driver.c line 769
Quoted 9 lines
drivers/misc/sep/sep_driver.c new file +9
-0+/* Ensure data is in little endian */ + hash_buf_ptr = (u32 *)sep->shared_addr + +SEP_CALLER_ID_OFFSET_BYTES ; + +for (i =0 ; i <SEP_CALLER_ID_HASH_SIZE_IN_WORDS ; i++) + hash_buf_ptr[i] =cpu_to_le32 (hash_buf_ptr[i]); + +return 0 ; +}
It would be more efficient to check the list first and do nothing if the pid isn't found in the list.
Quoted 8 lines
drivers/misc/sep/sep_driver.c new file +8
-0+ +/** +* sep_send_command_handler - kick off a command +* @sep: SEP being signalled +* +* This function raises interrupt to SEP that signals that is has a new +* command from the host +*
drivers/misc/sep/sep_driver.c line 787
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+* Note that this function does fall under the ioctl lock +*/ +static int sep_send_command_handler (struct sep_device *sep) +{ +unsigned long lck_flags; +int error =0 ; + +if (test_and_set_bit (SEP_SEND_MSG_LOCK_BIT , &sep->in_use_flags)) { + error = -EPROTO ; + goto end_function;
'return -EPROTO;'
drivers/misc/sep/sep_driver.c line 789
Quoted 2 lines
drivers/misc/sep/sep_driver.c new file +2
-0+ } +sep_set_time (sep);
You need to set the time for each command? What is the device doing with this?
Quoted 26 lines
drivers/misc/sep/sep_driver.c new file +26
-0+ +sep_set_current_caller_id (sep); + +sep_dump_message (sep); + +/* Update counter */ +spin_lock_irqsave (&sep->snd_rply_lck, lck_flags); + sep->send_ct++; +spin_unlock_irqrestore (&sep->snd_rply_lck, lck_flags); + +dev_dbg (&sep->pdev->dev, +"sep_send_command_handler send_ct %lx reply_ct %lx\n" , + sep->send_ct, sep->reply_ct); + +/* Send interrupt to SEP */ +sep_write_reg (sep,HW_HOST_HOST_SEP_GPR0_REG_ADDR ,0x2 ); + +end_function: +return error; +} + +/** +* sep_allocate_data_pool_memory_handler -allocate pool memory +* @sep: pointer to struct sep_device +* @arg: pointer to struct alloc_struct +*
drivers/misc/sep/sep_driver.c line 825
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+* This function handles the allocate data pool memory request +* This function returns calculates the bus address of the +* allocated memory, and the offset of this area from the mapped address. +* Therefore, the FVOs in user space can calculate the exact virtual +* address of this allocated memory +*/ +static int sep_allocate_data_pool_memory_handler (struct sep_device *sep, +unsigned long arg) +{ +int error =0 ;
Again, not needed. I'm going to stop flagging this issue in the rest of the code, but you should remove the unnecessary error vars and remove the goto's--it is harder to read and less efficient.
Quoted 28 lines
drivers/misc/sep/sep_driver.c new file +28
-0+struct alloc_struct command_args; + +/* Holds the allocated buffer address in the system memory pool */ +u32 *token_addr; + +if (copy_from_user (&command_args, (void __user *)arg, +sizeof (struct alloc_struct ))) { + error = -EFAULT ; + goto end_function; + } + +/* Allocate memory */ +if ((sep->data_pool_bytes_allocated + command_args.num_bytes) > +SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES ) { + error = -ENOMEM ; + goto end_function; + } + +dev_dbg (&sep->pdev->dev, +"data pool bytes_allocated: %x\n" , (int )sep->data_pool_bytes_allocated); +dev_dbg (&sep->pdev->dev, +"offset: %x\n" ,SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES ); +/* Set the virtual and bus address */ + command_args.offset =SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + + sep->data_pool_bytes_allocated; + +/* Place in the shared area that is known by the SEP */ + token_addr = (u32 *)(sep->shared_addr +
drivers/misc/sep/sep_driver.c line 863
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+SEP_DRIVER_DATA_POOL_ALLOCATION_OFFSET_IN_BYTES + + (sep->num_of_data_allocations)*2*sizeof(u32)); + + token_addr[0 ] =SEP_DATA_POOL_POINTERS_VAL_TOKEN ; + token_addr[1 ] = (u32 )sep->shared_bus + +SEP_DRIVER_DATA_POOL_AREA_OFFSET_IN_BYTES + + sep->data_pool_bytes_allocated; + +/* Write the memory back to the user space */ + error = copy_to_user((void *)arg, (void *)&command_args,
'(void __user *)arg'?
You should do this before writing to the SEP shared space, since this can fail.
Quoted 14 lines
drivers/misc/sep/sep_driver.c new file +14
-0+ sizeof(struct alloc_struct)); +if (error) { + error = -EFAULT ; + goto end_function; + } + +/* Update the allocation */ + sep->data_pool_bytes_allocated += command_args.num_bytes; + sep->num_of_data_allocations +=1 ; + +end_function: +return error; +} +
drivers/misc/sep/sep_driver.c line 887
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+/** +* sep_lock_kernel_pages - map kernel pages for DMA +* @sep: pointer to struct sep_device +* @kernel_virt_addr: address of data buffer in kernel +* @data_size: size of data +* @lli_array_ptr: lli array +* @in_out_flag: input into device or output from device +* +* This function locks all the physical pages of the kernel virtual buffer +* and construct a basic lli array, where each entry holds the physical
"lli array," => "lli array,"
Quoted 25 lines
drivers/misc/sep/sep_driver.c new file +25
-0+* page address and the size that application data holds in this page +* This function is used only during kernel crypto mod calls from within +* the kernel (when ioctl is not used) +*/ +static int sep_lock_kernel_pages (struct sep_device *sep, +unsigned long kernel_virt_addr, +u32 data_size, +struct sep_lli_entry **lli_array_ptr, +int in_out_flag) + +{ +int error =0 ; +/* Array of lli */ +struct sep_lli_entry *lli_array; +/* Map array */ +struct sep_dma_map *map_array; + +dev_dbg (&sep->pdev->dev,"lock kernel pages kernel_virt_addr is %08lx\n" , + (unsigned long )kernel_virt_addr); +dev_dbg (&sep->pdev->dev,"data_size is %x\n" , data_size); + + lli_array =kmalloc (sizeof (struct sep_lli_entry ),GFP_ATOMIC ); +if (!lli_array) { + error = -ENOMEM ; + goto end_function;
drivers/misc/sep/sep_driver.c line 922
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+ } + map_array =kmalloc (sizeof (struct sep_dma_map ),GFP_ATOMIC ); +if (!map_array) { + error = -ENOMEM ; + goto end_function_with_error; + } + + map_array[0 ].dma_addr = +dma_map_single (&sep->pdev->dev, (void *)kernel_virt_addr, + data_size,DMA_BIDIRECTIONAL );
There is only one element in this, so just use 'map_array->' notation. Why don't you check this for an error?
drivers/misc/sep/sep_driver.c line 930
Quoted 8 lines
drivers/misc/sep/sep_driver.c new file +8
-0+ map_array[0 ].size = data_size; + + +/* +* Set the start address of the first page - app data may start not at +* the beginning of the page +*/ + lli_array[0 ].bus_address = (u32 )map_array[0 ].dma_addr;
Ditto for using '->' syntax.
drivers/misc/sep/sep_driver.c line 940
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+ lli_array[0 ].block_size = map_array[0 ].size; + +dev_dbg (&sep->pdev->dev, +"lli_array[0].bus_address is %08lx, lli_array[0].block_size is %x\n" , + (unsigned long )lli_array[0 ].bus_address, + lli_array[0 ].block_size); + +/* Set the output parameters */ +if (in_out_flag ==SEP_DRIVER_IN_FLAG ) { + *lli_array_ptr = lli_array;
Test lli_array_ptr for NULL.
drivers/misc/sep/sep_driver.c line 946
Quoted 6 lines
drivers/misc/sep/sep_driver.c new file +6
-0+ sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages =1 ; + sep->dma_res_arr[sep->nr_dcb_creat].in_page_array =NULL ; + sep->dma_res_arr[sep->nr_dcb_creat].in_map_array = map_array; + sep->dma_res_arr[sep->nr_dcb_creat].in_map_num_entries =1 ; + }else { + *lli_array_ptr = lli_array;
Ditto.
drivers/misc/sep/sep_driver.c line 951
Quoted 5 lines
drivers/misc/sep/sep_driver.c new file +5
-0+ sep->dma_res_arr[sep->nr_dcb_creat].out_num_pages =1 ; + sep->dma_res_arr[sep->nr_dcb_creat].out_page_array =NULL ; + sep->dma_res_arr[sep->nr_dcb_creat].out_map_array = map_array; + sep->dma_res_arr[sep->nr_dcb_creat].out_map_num_entries =1 ; + }
You don't need to increment sep->nr_dcb_creat?
Quoted 9 lines
drivers/misc/sep/sep_driver.c new file +9
-0+ goto end_function; + +end_function_with_error: +kfree (lli_array); + +end_function: +return error; +} +
drivers/misc/sep/sep_driver.c line 970
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+/** +* sep_lock_user_pages - lock and map user pages for DMA +* @sep: pointer to struct sep_device +* @app_virt_addr: user memory data buffer +* @data_size: size of data buffer +* @lli_array_ptr: lli array +* @in_out_flag: input or output to device +* +* This function locks all the physical pages of the application +* virtual buffer and construct a basic lli array, where each entry
"lli array," => "lli array,"
drivers/misc/sep/sep_driver.c line 975
Quoted 5 lines
drivers/misc/sep/sep_driver.c new file +5
-0+* holds the physical page address and the size that application +* data holds in this physical pages +*/ +static int sep_lock_user_pages(struct sep_device *sep, + u32 app_virt_addr,
Why not u64--how will you handle the max userspace VA?
drivers/misc/sep/sep_driver.c line 984
Quoted 9 lines
drivers/misc/sep/sep_driver.c new file +9
-0+u32 data_size, + struct sep_lli_entry **lli_array_ptr, + int in_out_flag) + +{ + int error = 0; +u32 count; +int result; +/* The the page of the end address of the user space buffer */
"The the" => "The"
Quoted 5 lines
drivers/misc/sep/sep_driver.c new file +5
-0+u32 end_page; +/* The page of the start address of the user space buffer */ +u32 start_page; +/* The range in pages */ +u32 num_pages;
drivers/misc/sep/sep_driver.c line 999
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+/* Array of pointers to page */ +struct page **page_array; +/* Array of lli */ +struct sep_lli_entry *lli_array; +/* Map array */ +struct sep_dma_map *map_array; +/* Direction of the DMA mapping for locked pages */ +enum dma_data_direction dir; + +/* Set start and end pages and num pages */
"pages and" => "pages and"
Quoted 56 lines
drivers/misc/sep/sep_driver.c new file +56
-0+ end_page = (app_virt_addr + data_size -1 ) >>PAGE_SHIFT ; + start_page = app_virt_addr >>PAGE_SHIFT ; + num_pages = end_page - start_page +1 ; + +dev_dbg (&sep->pdev->dev,"lock user pages app_virt_addr is %x\n" , app_virt_addr); +dev_dbg (&sep->pdev->dev,"data_size is %x\n" , data_size); +dev_dbg (&sep->pdev->dev,"start_page is %x\n" , start_page); +dev_dbg (&sep->pdev->dev,"end_page is %x\n" , end_page); +dev_dbg (&sep->pdev->dev,"num_pages is %x\n" , num_pages); + +/* Allocate array of pages structure pointers */ + page_array =kmalloc (sizeof (struct page *) * num_pages,GFP_ATOMIC ); +if (!page_array) { + error = -ENOMEM ; + goto end_function; + } + map_array =kmalloc (sizeof (struct sep_dma_map ) * num_pages,GFP_ATOMIC ); +if (!map_array) { +dev_warn (&sep->pdev->dev,"kmalloc for map_array failed\n" ); + error = -ENOMEM ; + goto end_function_with_error1; + } + + lli_array =kmalloc (sizeof (struct sep_lli_entry ) * num_pages, +GFP_ATOMIC ); + +if (!lli_array) { +dev_warn (&sep->pdev->dev,"kmalloc for lli_array failed\n" ); + error = -ENOMEM ; + goto end_function_with_error2; + } + +/* Convert the application virtual address into a set of physical */ +down_read (¤t->mm->mmap_sem); + result =get_user_pages (current, current->mm, app_virt_addr, + num_pages, + ((in_out_flag ==SEP_DRIVER_IN_FLAG ) ?0 :1 ), +0 , page_array,NULL ); + +up_read (¤t->mm->mmap_sem); + +/* Check the number of pages locked - if not all then exit with error */ +if (result != num_pages) { +dev_warn (&sep->pdev->dev, +"not all pages locked by get_user_pages\n" ); + error = -ENOMEM ; + goto end_function_with_error3; + } + +dev_dbg (&sep->pdev->dev,"get_user_pages succeeded\n" ); + +/* Set direction */ +if (in_out_flag ==SEP_DRIVER_IN_FLAG ) + dir =DMA_TO_DEVICE ; +else + dir =DMA_FROM_DEVICE ;
drivers/misc/sep/sep_driver.c line 1065
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+ +/* +* Fill the array using page array data and +* map the pages - this action will also flush the cache as needed +*/ +for (count =0 ; count < num_pages; count++) { +/* Fill the map array */ + map_array[count].dma_addr = +dma_map_page (&sep->pdev->dev, page_array[count], +0 ,PAGE_SIZE ,/*dir*/ DMA_BIDIRECTIONAL );
Why DMA_BIDIRECTIONAL and not dir?
Handle failure?
Quoted 9 lines
drivers/misc/sep/sep_driver.c new file +8
-0+ + map_array[count].size =PAGE_SIZE ; + +/* Fill the lli array entry */ + lli_array[count].bus_address = (u32 )map_array[count].dma_addr; + lli_array[count].block_size =PAGE_SIZE ; + + dev_warn(&sep->pdev->dev, "lli_array[%x].bus_address is %08lx,lli_array[%x].block_size is %x\n",
drivers/misc/sep/sep_driver.c line 1078
Quoted 5 lines
drivers/misc/sep/sep_driver.c new file +5
-0+ count, (unsigned long )lli_array[count].bus_address, + count, lli_array[count].block_size); + } + +/* Check the offset for the first page */
This isn't a "check", it's a "set"/assignment. And it needs a (better) explanation.
drivers/misc/sep/sep_driver.c line 1085
Quoted 7 lines
drivers/misc/sep/sep_driver.c new file +7
-0+ lli_array[0 ].bus_address = + lli_array[0 ].bus_address + (app_virt_addr & (~PAGE_MASK )); + +/* Check that not all the data is in the first page only */ +if ((PAGE_SIZE - (app_virt_addr & (~PAGE_MASK ))) >= data_size) + lli_array[0 ].block_size = data_size; +else
Also needs an explanation.
Quoted 14 lines
drivers/misc/sep/sep_driver.c new file +14
-0+ lli_array[0 ].block_size = +PAGE_SIZE - (app_virt_addr & (~PAGE_MASK )); + +dev_dbg (&sep->pdev->dev, +"lli_array[0].bus_address is %08lx, lli_array[0].block_size is %x\n" , + (unsigned long )lli_array[count].bus_address, + lli_array[count].block_size); + +/* Check the size of the last page */ +if (num_pages >1 ) { + lli_array[num_pages -1 ].block_size = + (app_virt_addr + data_size) & (~PAGE_MASK ); + + dev_warn(&sep->pdev->dev,
drivers/misc/sep/sep_driver.c line 1109
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+"lli_array[%x].bus_address is %08lx, lli_array[%x].block_size is %x\n" , + num_pages -1 , + (unsigned long )lli_array[count].bus_address, + num_pages -1 , + lli_array[count].block_size); + } + +/* Set output params according to the in_out flag */ +if (in_out_flag ==SEP_DRIVER_IN_FLAG ) { + *lli_array_ptr = lli_array;
NULL check
Quoted 16 lines
drivers/misc/sep/sep_driver.c new file +16
-0+ sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages = num_pages; + sep->dma_res_arr[sep->nr_dcb_creat].in_page_array = page_array; + sep->dma_res_arr[sep->nr_dcb_creat].in_map_array = map_array; + sep->dma_res_arr[sep->nr_dcb_creat].in_map_num_entries = + num_pages; + }else { + *lli_array_ptr = lli_array; + sep->dma_res_arr[sep->nr_dcb_creat].out_num_pages = num_pages; + sep->dma_res_arr[sep->nr_dcb_creat].out_page_array = + page_array; + sep->dma_res_arr[sep->nr_dcb_creat].out_map_array = map_array; + sep->dma_res_arr[sep->nr_dcb_creat].out_map_num_entries = + num_pages; + } + goto end_function; +
drivers/misc/sep/sep_driver.c line 1135
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+end_function_with_error3: +/* Free lli array */ +kfree (lli_array); + +end_function_with_error2: +kfree (map_array); + +end_function_with_error1: +/* Free page array */ +kfree (page_array);
If you assign NULL to these initially then you can have a single error entry that free's all of them.
Quoted 19 lines
drivers/misc/sep/sep_driver.c new file +19
-0+ +end_function: +return error; +} + +/** +* u32 sep_calculate_lli_table_max_size - size the LLI table +* @sep: pointer to struct sep_device +* @lli_in_array_ptr +* @num_array_entries +* @last_table_flag +* +* This function calculates the size of data that can be inserted into +* the lli table from this array, such that either the table is full +* (all entries are entered), or there are no more entries in the +* lli array +*/ +static u32 sep_calculate_lli_table_max_size(struct sep_device *sep, + struct sep_lli_entry *lli_in_array_ptr,
drivers/misc/sep/sep_driver.c line 1164
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+u32 num_array_entries, + u32 *last_table_flag) +{ + u32 counter; +/* Table data size */ +u32 table_data_size =0 ; +/* Data size for the next table */ +u32 next_table_data_size; + + *last_table_flag =0 ;
NULL check. Also the last time I'll flag this--it is best to check even internal calls unless there is no chance that current or future code could have bug which passes NULL.
drivers/misc/sep/sep_driver.c line 1171
Quoted 7 lines
drivers/misc/sep/sep_driver.c new file +7
-0+ +/* +* Calculate the data in the out lli table till we fill the whole +* table or till the data has ended +*/ + for (counter = 0; + (counter < (SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP - 1)) &&
Why 'SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP - 1'?
drivers/misc/sep/sep_driver.c line 1173
Quoted 2 lines
drivers/misc/sep/sep_driver.c new file +2
-0+ (counter < num_array_entries); counter++) + table_data_size += lli_in_array_ptr[counter].block_size;
NULL check lli_in_array_ptr
drivers/misc/sep/sep_driver.c line 1177
Quoted 4 lines
drivers/misc/sep/sep_driver.c new file +4
-0+ +/* +* Check if we reached the last entry, +* meaning this ia the last table to build,
"ia" => "is"
Quoted 15 lines
drivers/misc/sep/sep_driver.c new file +15
-0+* and no need to check the block alignment +*/ +if (counter == num_array_entries) { +/* Set the last table flag */ + *last_table_flag =1 ; + goto end_function; + } + +/* +* Calculate the data size of the next table. +* Stop if no entries left or if data size is more the DMA restriction +*/ + next_table_data_size =0 ; +for (; counter < num_array_entries; counter++) { + next_table_data_size += lli_in_array_ptr[counter].block_size;
drivers/misc/sep/sep_driver.c line 1202
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+if (next_table_data_size >=SEP_DRIVER_MIN_DATA_SIZE_PER_TABLE ) +break ; + } + +/* +* Check if the next table data size is less then DMA rstriction. +* if it is - recalculate the current table size, so that the next +* table data size will be adaquete for DMA +*/ + if (next_table_data_size &&
How can next_table_data_size == 0?
Quoted 32 lines
drivers/misc/sep/sep_driver.c new file +32
-0+ next_table_data_size < SEP_DRIVER_MIN_DATA_SIZE_PER_TABLE) + + table_data_size -= (SEP_DRIVER_MIN_DATA_SIZE_PER_TABLE - + next_table_data_size); + +end_function: +return table_data_size; +} + +/** +* sep_build_lli_table - build an lli array for the given table +* @sep: pointer to struct sep_device +* @lli_array_ptr: pointer to lli array +* @lli_table_ptr: pointer to lli table +* @num_processed_entries_ptr: pointer to number of entries +* @num_table_entries_ptr: pointer to number of tables +* @table_data_size: total data size +* +* Builds ant lli table from the lli_array according to +* the given size of data +*/ +static void sep_build_lli_table (struct sep_device *sep, +struct sep_lli_entry *lli_array_ptr, +struct sep_lli_entry *lli_table_ptr, +u32 *num_processed_entries_ptr, +u32 *num_table_entries_ptr, +u32 table_data_size) +{ +/* Current table data size */ +u32 curr_table_data_size; +/* Counter of lli array entry */ +u32 array_counter;
drivers/misc/sep/sep_driver.c line 1244
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+ +/* Init currrent table data size and lli array entry counter */ + curr_table_data_size =0 ; + array_counter =0 ; + *num_table_entries_ptr =1 ; + +dev_dbg (&sep->pdev->dev,"build lli table table_data_size is %x\n" , table_data_size); + +/* Fill the table till table size reaches the needed amount */ +while (curr_table_data_size < table_data_size) {
It seems risky not to be checking that you don't go past the end of lli_table_ptr's allocated memory.
Quoted 55 lines
drivers/misc/sep/sep_driver.c new file +55
-0+/* Update the number of entries in table */ + (*num_table_entries_ptr)++; + + lli_table_ptr->bus_address = +cpu_to_le32 (lli_array_ptr[array_counter].bus_address); + + lli_table_ptr->block_size = +cpu_to_le32 (lli_array_ptr[array_counter].block_size); + + curr_table_data_size += lli_array_ptr[array_counter].block_size; + +dev_dbg (&sep->pdev->dev,"lli_table_ptr is %p\n" , + lli_table_ptr); +dev_dbg (&sep->pdev->dev,"lli_table_ptr->bus_address is %08lx\n" , + (unsigned long )lli_table_ptr->bus_address); +dev_dbg (&sep->pdev->dev,"lli_table_ptr->block_size is %x\n" , + lli_table_ptr->block_size); + +/* Check for overflow of the table data */ +if (curr_table_data_size > table_data_size) { +dev_dbg (&sep->pdev->dev, +"curr_table_data_size too large\n" ); + +/* Update the size of block in the table */ + lli_table_ptr->block_size -= +cpu_to_le32 ((curr_table_data_size - table_data_size)); + +/* Update the physical address in the lli array */ + lli_array_ptr[array_counter].bus_address += +cpu_to_le32 (lli_table_ptr->block_size); + +/* Update the block size left in the lli array */ + lli_array_ptr[array_counter].block_size = + (curr_table_data_size - table_data_size); + }else +/* Advance to the next entry in the lli_array */ + array_counter++; + +dev_dbg (&sep->pdev->dev, +"lli_table_ptr->bus_address is %08lx\n" , + (unsigned long )lli_table_ptr->bus_address); +dev_dbg (&sep->pdev->dev, +"lli_table_ptr->block_size is %x\n" , + lli_table_ptr->block_size); + +/* Move to the next entry in table */ + lli_table_ptr++; + } + +/* Set the info entry to default */ + lli_table_ptr->bus_address =0xffffffff ; + lli_table_ptr->block_size =0 ; + +/* Set the output parameter */ + *num_processed_entries_ptr += array_counter;
drivers/misc/sep/sep_driver.c line 1309
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+ +} + +/** +* sep_shared_area_virt_to_bus - map shared area to bus address +* @sep: pointer to struct sep_device +* @virt_address: virtual address to convert +* +* This functions returns the physical address inside shared area according +* to the virtual address. It can be either on the externa RAM device
"externa" => "external"
Quoted 12 lines
+ * (ioremapped), or on the system RAM
+ * This implementation is for the external RAM
+ */drivers/misc/sep/sep_driver.c new file +9
-0+static dma_addr_t sep_shared_area_virt_to_bus (struct sep_device *sep, +void *virt_address) +{ +dev_dbg (&sep->pdev->dev,"sh virt to phys v %p\n" , virt_address); +dev_dbg (&sep->pdev->dev,"sh virt to phys p %08lx\n" , + (unsigned long ) + sep->shared_bus + (virt_address - sep->shared_addr)); + +return sep->shared_bus + (size_t )(virt_address - sep->shared_addr);
drivers/misc/sep/sep_driver.c line 1331
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+} + +/** +* sep_shared_area_bus_to_virt - map shared area bus address to kernel +* @sep: pointer to struct sep_device +* @bus_address: bus address to convert +* +* This functions returns the virtual address inside shared area +* according to the physical address. It can be either on the +* externa RAM device (ioremapped), or on the system RAM
"externa" => "external"
Quoted 126 lines
+ * This implementation is for the external RAM
+ */drivers/misc/sep/sep_driver.c new file +124
-0+static void *sep_shared_area_bus_to_virt (struct sep_device *sep, +dma_addr_t bus_address) +{ +dev_dbg (&sep->pdev->dev,"shared bus to virt b=%lx v=%lx\n" , + (unsigned long )bus_address, (unsigned long )(sep->shared_addr + + (size_t )(bus_address - sep->shared_bus))); + +return sep->shared_addr + (size_t )(bus_address - sep->shared_bus); +} + +/** +* sep_debug_print_lli_tables - dump LLI table +* @sep: pointer to struct sep_device +* @lli_table_ptr: pointer to sep_lli_entry +* @num_table_entries: number of entries +* @table_data_size: total data size +* +* Walk the the list of the print created tables and print all the data +*/ +static void sep_debug_print_lli_tables (struct sep_device *sep, +struct sep_lli_entry *lli_table_ptr, +unsigned long num_table_entries, +unsigned long table_data_size) +{ +unsigned long table_count =1 ; +unsigned long entries_count =0 ; + +dev_dbg (&sep->pdev->dev,"sep_debug_print_lli_tables start\n" ); + +while ((unsigned long ) lli_table_ptr->bus_address !=0xffffffff ) { +dev_dbg (&sep->pdev->dev, +"lli table %08lx, table_data_size is %lu\n" , + table_count, table_data_size); +dev_dbg (&sep->pdev->dev,"num_table_entries is %lu\n" , + num_table_entries); + +/* Print entries of the table (without info entry) */ +for (entries_count =0 ; entries_count < num_table_entries; + entries_count++, lli_table_ptr++) { + +dev_dbg (&sep->pdev->dev, +"lli_table_ptr address is %08lx\n" , + (unsigned long ) lli_table_ptr); + +dev_dbg (&sep->pdev->dev, +"phys address is %08lx block size is %x\n" , + (unsigned long )lli_table_ptr->bus_address, + lli_table_ptr->block_size); + } +/* Point to the info entry */ + lli_table_ptr--; + +dev_dbg (&sep->pdev->dev, +"phys lli_table_ptr->block_size is %x\n" , + lli_table_ptr->block_size); + +dev_dbg (&sep->pdev->dev, +"phys lli_table_ptr->physical_address is %08lu\n" , + (unsigned long )lli_table_ptr->bus_address); + + + table_data_size = lli_table_ptr->block_size &0xffffff ; + num_table_entries = (lli_table_ptr->block_size >>24 ) &0xff ; + +dev_dbg (&sep->pdev->dev, +"phys table_data_size is %lu num_table_entries is" +" %lu bus_address is%lu\n" , table_data_size, + num_table_entries, (unsigned long )lli_table_ptr->bus_address); + +if ((unsigned long )lli_table_ptr->bus_address !=0xffffffff ) + lli_table_ptr = (struct sep_lli_entry *) +sep_shared_bus_to_virt (sep, + (unsigned long )lli_table_ptr->bus_address); + + table_count++; + } +dev_dbg (&sep->pdev->dev,"sep_debug_print_lli_tables end\n" ); +} + + +/** +* sep_prepare_empty_lli_table - create a blank LLI table +* @sep: pointer to struct sep_device +* @lli_table_addr_ptr: pointer to lli table +* @num_entries_ptr: pointer to number of entries +* @table_data_size_ptr: point to table data size +* +* This function creates empty lli tables when there is no data +*/ +static void sep_prepare_empty_lli_table (struct sep_device *sep, +dma_addr_t *lli_table_addr_ptr, +u32 *num_entries_ptr, +u32 *table_data_size_ptr) +{ +struct sep_lli_entry *lli_table_ptr; + +/* Find the area for new table */ + lli_table_ptr = + (struct sep_lli_entry *)(sep->shared_addr + +SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES + + sep->num_lli_tables_created *sizeof (struct sep_lli_entry ) * +SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP ); + + lli_table_ptr->bus_address =0 ; + lli_table_ptr->block_size =0 ; + + lli_table_ptr++; + lli_table_ptr->bus_address =0xFFFFFFFF ; + lli_table_ptr->block_size =0 ; + +/* Set the output parameter value */ + *lli_table_addr_ptr = sep->shared_bus + +SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES + + sep->num_lli_tables_created * +sizeof (struct sep_lli_entry ) * +SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP ; + +/* Set the num of entries and table data size for empty table */ + *num_entries_ptr =2 ; + *table_data_size_ptr =0 ; + +/* Update the number of created tables */ + sep->num_lli_tables_created++; +}
drivers/misc/sep/sep_driver.c line 1467
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+ +/** +* sep_prepare_input_dma_table - prepare input DMA mappings +* @sep: pointer to struct sep_device +* @data_size: +* @block_size: +* @lli_table_ptr: +* @num_entries_ptr: +* @table_data_size_ptr: +* @is_kva: set for kernel data (kernel cryptio call)
"cryptio" => "crypto"
Quoted 2 lines
+ *
+ * This function prepares only input DMA table for synhronic symmetric
"synhronic" => "synchronous"
Quoted 38 lines
+ * operations (HASH) + * Note that all bus addresses that are passed to the SEP + * are in 32 bit format; the SEP is a 32 bit device+ */
drivers/misc/sep/sep_driver.c new file +34
-0+static int sep_prepare_input_dma_table (struct sep_device *sep, +unsigned long app_virt_addr, +u32 data_size, +u32 block_size, +dma_addr_t *lli_table_ptr, +u32 *num_entries_ptr, +u32 *table_data_size_ptr, +bool is_kva) +{ +int error =0 ; +/* Pointer to the info entry of the table - the last entry */ +struct sep_lli_entry *info_entry_ptr; +/* Array of pointers to page */ +struct sep_lli_entry *lli_array_ptr; +/* Points to the first entry to be processed in the lli_in_array */ +u32 current_entry =0 ; +/* Num entries in the virtual buffer */ +u32 sep_lli_entries =0 ; +/* Lli table pointer */ +struct sep_lli_entry *in_lli_table_ptr; +/* The total data in one table */ +u32 table_data_size =0 ; +/* Flag for last table */ +u32 last_table_flag =0 ; +/* Number of entries in lli table */ +u32 num_entries_in_table =0 ; +/* Next table address */ +void *lli_table_alloc_addr =0 ; + +dev_dbg (&sep->pdev->dev,"prepare intput dma table data_size is %x\n" , data_size); +dev_dbg (&sep->pdev->dev,"block_size is %x\n" , block_size); + +/* Initialize the pages pointers */ + sep->dma_res_arr[sep->nr_dcb_creat].in_page_array =NULL ;
drivers/misc/sep/sep_driver.c line 1517
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+ sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages =0 ; + +/* Set the kernel address for first table to be allocated */ + lli_table_alloc_addr = (void *)(sep->shared_addr + +SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES + + sep->num_lli_tables_created *sizeof (struct sep_lli_entry ) * +SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP ); + +if (data_size ==0 ) { +/* Special case - create meptu table - 2 entries, zero data */
"meptu"?
drivers/misc/sep/sep_driver.c line 1524
Quoted 7 lines
drivers/misc/sep/sep_driver.c new file +7
-0+sep_prepare_empty_lli_table (sep, lli_table_ptr, + num_entries_ptr, table_data_size_ptr); + goto update_dcb_counter; + } + +/* Check if the pages are in Kernel Virtual Address layout */ +if (is_kva == true)
Just '(is_kva)'
Quoted 29 lines
drivers/misc/sep/sep_driver.c new file +29
-0+/* Lock the pages in the kernel */ + error =sep_lock_kernel_pages (sep, app_virt_addr, + data_size, &lli_array_ptr,SEP_DRIVER_IN_FLAG ); + else +/* +* Lock the pages of the user buffer +* and translate them to pages +*/ + error =sep_lock_user_pages (sep, app_virt_addr, + data_size, &lli_array_ptr,SEP_DRIVER_IN_FLAG ); + +if (error) + goto end_function; + +dev_dbg (&sep->pdev->dev,"output sep_in_num_pages is %x\n" , + sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages); + + current_entry =0 ; + info_entry_ptr =NULL ; + + sep_lli_entries = sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages; + +/* Loop till all the entries in in array are not processed */ +while (current_entry < sep_lli_entries) { + +/* Set the new input and output tables */ + in_lli_table_ptr = + (struct sep_lli_entry *)lli_table_alloc_addr; +
drivers/misc/sep/sep_driver.c line 1563
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+ lli_table_alloc_addr +=sizeof (struct sep_lli_entry ) * +SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP ; + +if (lli_table_alloc_addr > + ((void *)sep->shared_addr + +SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES + +SYNCHRONIC_DMA_TABLES_AREA_SIZE_BYTES )) { + + error = -ENOMEM ; + goto end_function_error;
You've already locked the pages--don't you need to unlock them?
Quoted 125 lines
drivers/misc/sep/sep_driver.c new file +125
-0+ + } + +/* Update the number of created tables */ + sep->num_lli_tables_created++; + +/* Calculate the maximum size of data for input table */ + table_data_size =sep_calculate_lli_table_max_size (sep, + &lli_array_ptr[current_entry], + (sep_lli_entries - current_entry), + &last_table_flag); + +/* +* If this is not the last table - +* then align it to the block size +*/ +if (!last_table_flag) + table_data_size = + (table_data_size / block_size) * block_size; + +dev_dbg (&sep->pdev->dev,"output table_data_size is %x\n" , + table_data_size); + +/* Construct input lli table */ +sep_build_lli_table (sep, &lli_array_ptr[current_entry], + in_lli_table_ptr, + ¤t_entry, &num_entries_in_table, table_data_size); + +if (info_entry_ptr ==NULL ) { + +/* Set the output parameters to physical addresses */ + *lli_table_ptr =sep_shared_area_virt_to_bus (sep, + in_lli_table_ptr); + *num_entries_ptr = num_entries_in_table; + *table_data_size_ptr = table_data_size; + +dev_dbg (&sep->pdev->dev, +"output lli_table_in_ptr is %08lx\n" , + (unsigned long )*lli_table_ptr); + + }else { +/* Update the info entry of the previous in table */ + info_entry_ptr->bus_address = +sep_shared_area_virt_to_bus (sep, + in_lli_table_ptr); + info_entry_ptr->block_size = + ((num_entries_in_table) <<24 ) | + (table_data_size); + } +/* Save the pointer to the info entry of the current tables */ + info_entry_ptr = in_lli_table_ptr + num_entries_in_table -1 ; + } +/* Print input tables */ +sep_debug_print_lli_tables (sep, (struct sep_lli_entry *) +sep_shared_area_bus_to_virt (sep, *lli_table_ptr), + *num_entries_ptr, *table_data_size_ptr); +/* The array of the pages */ +kfree (lli_array_ptr); + +update_dcb_counter: +/* Update DCB counter */ + sep->nr_dcb_creat++; + goto end_function; + +end_function_error: +/* Free all the allocated resources */ +kfree (sep->dma_res_arr[sep->nr_dcb_creat].in_map_array); +kfree (lli_array_ptr); +kfree (sep->dma_res_arr[sep->nr_dcb_creat].in_page_array); + +end_function: +return error; + +} +/** +* sep_construct_dma_tables_from_lli - prepare AES/DES mappings +* @sep: pointer to struct sep_device +* @lli_in_array: +* @sep_in_lli_entries: +* @lli_out_array: +* @sep_out_lli_entries +* @block_size +* @lli_table_in_ptr +* @lli_table_out_ptr +* @in_num_entries_ptr +* @out_num_entries_ptr +* @table_data_size_ptr +* +* This function creates the input and output DMA tables for +* symmetric operations (AES/DES) according to the block +* size from LLI arays +* Note that all bus addresses that are passed to the SEP +* are in 32 bit format; the SEP is a 32 bit device +*/ +static int sep_construct_dma_tables_from_lli ( +struct sep_device *sep, +struct sep_lli_entry *lli_in_array, +u32 sep_in_lli_entries, +struct sep_lli_entry *lli_out_array, +u32 sep_out_lli_entries, +u32 block_size, +dma_addr_t *lli_table_in_ptr, +dma_addr_t *lli_table_out_ptr, +u32 *in_num_entries_ptr, +u32 *out_num_entries_ptr, +u32 *table_data_size_ptr) +{ +/* Points to the area where next lli table can be allocated */ +void *lli_table_alloc_addr =0 ; +/* Input lli table */ +struct sep_lli_entry *in_lli_table_ptr =NULL ; +/* Output lli table */ +struct sep_lli_entry *out_lli_table_ptr =NULL ; +/* Pointer to the info entry of the table - the last entry */ +struct sep_lli_entry *info_in_entry_ptr =NULL ; +/* Pointer to the info entry of the table - the last entry */ +struct sep_lli_entry *info_out_entry_ptr =NULL ; +/* Points to the first entry to be processed in the lli_in_array */ +u32 current_in_entry =0 ; +/* Points to the first entry to be processed in the lli_out_array */ +u32 current_out_entry =0 ; +/* Max size of the input table */ +u32 in_table_data_size =0 ; +/* Max size of the output table */ +u32 out_table_data_size =0 ;
drivers/misc/sep/sep_driver.c line 1698
Quoted 10 lines
drivers/misc/sep/sep_driver.c new file +10
-0+/* Flag te signifies if this is the last tables build */ +u32 last_table_flag =0 ; +/* The data size that should be in table */ +u32 table_data_size =0 ; +/* Number of etnries in the input table */ +u32 num_entries_in_table =0 ; +/* Number of etnries in the output table */ +u32 num_entries_out_table =0 ; + +/* Initiate to point after the message area */
"Initiate" => "Initialize"
*** review stopped here ***
Quoted 5,787 lines
drivers/misc/sep/sep_driver.c new file +1230
-0+ lli_table_alloc_addr = (void *)(sep->shared_addr + +SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES + + (sep->num_lli_tables_created * + (sizeof (struct sep_lli_entry ) * +SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP ))); + +/* Loop till all the entries in in array are not processed */ +while (current_in_entry < sep_in_lli_entries) { +/* Set the new input and output tables */ + in_lli_table_ptr = + (struct sep_lli_entry *)lli_table_alloc_addr; + + lli_table_alloc_addr +=sizeof (struct sep_lli_entry ) * +SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP ; + +/* Set the first output tables */ + out_lli_table_ptr = + (struct sep_lli_entry *)lli_table_alloc_addr; + +/* Check if the DMA table area limit was overrun */ +if ((lli_table_alloc_addr +sizeof (struct sep_lli_entry ) * +SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP ) > + ((void *)sep->shared_addr + +SYNCHRONIC_DMA_TABLES_AREA_OFFSET_BYTES + +SYNCHRONIC_DMA_TABLES_AREA_SIZE_BYTES )) { + +dev_warn (&sep->pdev->dev,"dma table limit overrun\n" ); +return -ENOMEM ; + } + +/* Update the number of the lli tables created */ + sep->num_lli_tables_created +=2 ; + + lli_table_alloc_addr +=sizeof (struct sep_lli_entry ) * +SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP ; + +/* Calculate the maximum size of data for input table */ + in_table_data_size = +sep_calculate_lli_table_max_size (sep, + &lli_in_array[current_in_entry], + (sep_in_lli_entries - current_in_entry), + &last_table_flag); + +/* Calculate the maximum size of data for output table */ + out_table_data_size = +sep_calculate_lli_table_max_size (sep, + &lli_out_array[current_out_entry], + (sep_out_lli_entries - current_out_entry), + &last_table_flag); + +dev_dbg (&sep->pdev->dev, +"construct tables from lli in_table_data_size is %x\n" , + in_table_data_size); + +dev_dbg (&sep->pdev->dev, +"construct tables from lli out_table_data_size is %x\n" , + out_table_data_size); + + table_data_size = in_table_data_size; + +if (!last_table_flag) { +/* +* If this is not the last table, +* then must check where the data is smallest +* and then align it to the block size +*/ +if (table_data_size > out_table_data_size) + table_data_size = out_table_data_size; + +/* +* Now calculate the table size so that +* it will be module block size +*/ + table_data_size = (table_data_size / block_size) * + block_size; + } + +/* Construct input lli table */ +sep_build_lli_table (sep, &lli_in_array[current_in_entry], + in_lli_table_ptr, + ¤t_in_entry, + &num_entries_in_table, + table_data_size); + +/* Construct output lli table */ +sep_build_lli_table (sep, &lli_out_array[current_out_entry], + out_lli_table_ptr, + ¤t_out_entry, + &num_entries_out_table, + table_data_size); + +/* If info entry is null - this is the first table built */ +if (info_in_entry_ptr ==NULL ) { +/* Set the output parameters to physical addresses */ + *lli_table_in_ptr = +sep_shared_area_virt_to_bus (sep, in_lli_table_ptr); + + *in_num_entries_ptr = num_entries_in_table; + + *lli_table_out_ptr = +sep_shared_area_virt_to_bus (sep, + out_lli_table_ptr); + + *out_num_entries_ptr = num_entries_out_table; + *table_data_size_ptr = table_data_size; + +dev_dbg (&sep->pdev->dev, +"output lli_table_in_ptr is %08lx\n" , + (unsigned long )*lli_table_in_ptr); +dev_dbg (&sep->pdev->dev, +"output lli_table_out_ptr is %08lx\n" , + (unsigned long )*lli_table_out_ptr); + }else { +/* Update the info entry of the previous in table */ + info_in_entry_ptr->bus_address = +sep_shared_area_virt_to_bus (sep, + in_lli_table_ptr); + + info_in_entry_ptr->block_size = + ((num_entries_in_table) <<24 ) | + (table_data_size); + +/* Update the info entry of the previous in table */ + info_out_entry_ptr->bus_address = +sep_shared_area_virt_to_bus (sep, + out_lli_table_ptr); + + info_out_entry_ptr->block_size = + ((num_entries_out_table) <<24 ) | + (table_data_size); + +dev_dbg (&sep->pdev->dev, +"output lli_table_in_ptr:%08lx %08x\n" , + (unsigned long )info_in_entry_ptr->bus_address, + info_in_entry_ptr->block_size); + +dev_dbg (&sep->pdev->dev, +"output lli_table_out_ptr:%08lx %08x\n" , + (unsigned long )info_out_entry_ptr->bus_address, + info_out_entry_ptr->block_size); + } + +/* Save the pointer to the info entry of the current tables */ + info_in_entry_ptr = in_lli_table_ptr + + num_entries_in_table -1 ; + info_out_entry_ptr = out_lli_table_ptr + + num_entries_out_table -1 ; + +dev_dbg (&sep->pdev->dev, +"output num_entries_out_table is %x\n" , + (u32 )num_entries_out_table); +dev_dbg (&sep->pdev->dev, +"output info_in_entry_ptr is %lx\n" , + (unsigned long )info_in_entry_ptr); +dev_dbg (&sep->pdev->dev, +"output info_out_entry_ptr is %lx\n" , + (unsigned long )info_out_entry_ptr); + } + +/* Print input tables */ +sep_debug_print_lli_tables (sep, + (struct sep_lli_entry *) +sep_shared_area_bus_to_virt (sep, *lli_table_in_ptr), + *in_num_entries_ptr, + *table_data_size_ptr); + +/* Print output tables */ +sep_debug_print_lli_tables (sep, + (struct sep_lli_entry *) +sep_shared_area_bus_to_virt (sep, *lli_table_out_ptr), + *out_num_entries_ptr, + *table_data_size_ptr); + +return 0 ; +} + +/** +* sep_prepare_input_output_dma_table - prepare DMA I/O table +* @app_virt_in_addr: +* @app_virt_out_addr: +* @data_size: +* @block_size: +* @lli_table_in_ptr: +* @lli_table_out_ptr: +* @in_num_entries_ptr: +* @out_num_entries_ptr: +* @table_data_size_ptr: +* @is_kva: set for kernel data; used only for kernel crypto module +* +* This function builds input and output DMA tables for synhronic +* symmetric operations (AES, DES, HASH). It also checks that each table +* is of the modular block size +* Note that all bus addresses that are passed to the SEP +* are in 32 bit format; the SEP is a 32 bit device +*/ +static int sep_prepare_input_output_dma_table (struct sep_device *sep, +unsigned long app_virt_in_addr, +unsigned long app_virt_out_addr, +u32 data_size, +u32 block_size, +dma_addr_t *lli_table_in_ptr, +dma_addr_t *lli_table_out_ptr, +u32 *in_num_entries_ptr, +u32 *out_num_entries_ptr, +u32 *table_data_size_ptr, +bool is_kva) + +{ +int error =0 ; +/* Array of pointers of page */ +struct sep_lli_entry *lli_in_array; +/* Array of pointers of page */ +struct sep_lli_entry *lli_out_array; + +if (data_size ==0 ) { +/* Prepare empty table for input and output */ +sep_prepare_empty_lli_table (sep, lli_table_in_ptr, + in_num_entries_ptr, table_data_size_ptr); + +sep_prepare_empty_lli_table (sep, lli_table_out_ptr, + out_num_entries_ptr, table_data_size_ptr); + + goto update_dcb_counter; + } + +/* Initialize the pages pointers */ + sep->dma_res_arr[sep->nr_dcb_creat].in_page_array =NULL ; + sep->dma_res_arr[sep->nr_dcb_creat].out_page_array =NULL ; + +/* Lock the pages of the buffer and translate them to pages */ +if (is_kva == true) { + error =sep_lock_kernel_pages (sep, app_virt_in_addr, + data_size, &lli_in_array,SEP_DRIVER_IN_FLAG ); + +if (error) { +dev_warn (&sep->pdev->dev, +"lock kernel for in failed\n" ); + goto end_function; + } + + error =sep_lock_kernel_pages (sep, app_virt_out_addr, + data_size, &lli_out_array,SEP_DRIVER_OUT_FLAG ); + +if (error) { +dev_warn (&sep->pdev->dev, +"lock kernel for out failed\n" ); + goto end_function; + } + } + +else { + error =sep_lock_user_pages (sep, app_virt_in_addr, + data_size, &lli_in_array,SEP_DRIVER_IN_FLAG ); +if (error) { +dev_warn (&sep->pdev->dev, +"sep_lock_user_pages for input virtual buffer failed\n" ); + goto end_function; + } + + error =sep_lock_user_pages (sep, app_virt_out_addr, + data_size, &lli_out_array,SEP_DRIVER_OUT_FLAG ); + +if (error) { +dev_warn (&sep->pdev->dev, +"sep_lock_user_pages for output virtual buffer failed\n" ); + goto end_function_free_lli_in; + } + } + +dev_dbg (&sep->pdev->dev,"prep input output dma table sep_in_num_pages is %x\n" , + sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages); +dev_dbg (&sep->pdev->dev,"sep_out_num_pages is %x\n" , + sep->dma_res_arr[sep->nr_dcb_creat].out_num_pages); +dev_dbg (&sep->pdev->dev,"SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP is %x\n" , +SEP_DRIVER_ENTRIES_PER_TABLE_IN_SEP ); + +/* Call the function that creates table from the lli arrays */ + error =sep_construct_dma_tables_from_lli (sep, lli_in_array, + sep->dma_res_arr[sep->nr_dcb_creat].in_num_pages, + lli_out_array, + sep->dma_res_arr[sep->nr_dcb_creat].out_num_pages, + block_size, lli_table_in_ptr, lli_table_out_ptr, + in_num_entries_ptr, out_num_entries_ptr, table_data_size_ptr); + +if (error) { +dev_warn (&sep->pdev->dev, +"sep_construct_dma_tables_from_lli failed\n" ); + goto end_function_with_error; + } + +kfree (lli_out_array); +kfree (lli_in_array); + +update_dcb_counter: +/* Update DCB counter */ + sep->nr_dcb_creat++; + + goto end_function; + +end_function_with_error: +kfree (sep->dma_res_arr[sep->nr_dcb_creat].out_map_array); +kfree (sep->dma_res_arr[sep->nr_dcb_creat].out_page_array); +kfree (lli_out_array); + + +end_function_free_lli_in: +kfree (sep->dma_res_arr[sep->nr_dcb_creat].in_map_array); +kfree (sep->dma_res_arr[sep->nr_dcb_creat].in_page_array); +kfree (lli_in_array); + +end_function: + +return error; + +} + +/** +* sep_prepare_input_output_dma_table_in_dcb - prepare control blocks +* @app_in_address: unsigned long; for data buffer in (user space) +* @app_out_address: unsigned long; for data buffer out (user space) +* @data_in_size: u32; for size of data +* @block_size: u32; for block size +* @tail_block_size: u32; for size of tail block +* @isapplet: bool; to indicate external app +* @is_kva: bool; kernel buffer; only used for kernel crypto module +* +* This function prepares the linked DMA tables and puts the +* address for the linked list of tables inta a DCB (data control +* block) the address of which is known by the SEP hardware +* Note that all bus addresses that are passed to the SEP +* are in 32 bit format; the SEP is a 32 bit device +*/ +static int sep_prepare_input_output_dma_table_in_dcb (struct sep_device *sep, +unsigned long app_in_address, +unsigned long app_out_address, +u32 data_in_size, +u32 block_size, +u32 tail_block_size, +bool isapplet, +bool is_kva) +{ +int error =0 ; +/* Size of tail */ +u32 tail_size =0 ; +/* Address of the created DCB table */ +struct sep_dcblock *dcb_table_ptr =NULL ; +/* The physical address of the first input DMA table */ +dma_addr_t in_first_mlli_address =0 ; +/* Number of entries in the first input DMA table */ +u32 in_first_num_entries =0 ; +/* The physical address of the first output DMA table */ +dma_addr_t out_first_mlli_address =0 ; +/* Number of entries in the first output DMA table */ +u32 out_first_num_entries =0 ; +/* Data in the first input/output table */ +u32 first_data_size =0 ; + +if (sep->nr_dcb_creat ==SEP_MAX_NUM_SYNC_DMA_OPS ) { +/* No more DCBs to allocate */ +dev_warn (&sep->pdev->dev,"no more DCBs available\n" ); + error = -ENOSPC ; + goto end_function; + } + +/* Allocate new DCB */ + dcb_table_ptr = (struct sep_dcblock *)(sep->shared_addr + +SEP_DRIVER_SYSTEM_DCB_MEMORY_OFFSET_IN_BYTES + + (sep->nr_dcb_creat *sizeof (struct sep_dcblock ))); + +/* Set the default values in the DCB */ + dcb_table_ptr->input_mlli_address =0 ; + dcb_table_ptr->input_mlli_num_entries =0 ; + dcb_table_ptr->input_mlli_data_size =0 ; + dcb_table_ptr->output_mlli_address =0 ; + dcb_table_ptr->output_mlli_num_entries =0 ; + dcb_table_ptr->output_mlli_data_size =0 ; + dcb_table_ptr->tail_data_size =0 ; + dcb_table_ptr->out_vr_tail_pt =0 ; + +if (isapplet == true) { + +/* Check if there is enough data for DMA operation */ +if (data_in_size <SEP_DRIVER_MIN_DATA_SIZE_PER_TABLE ) { +if (is_kva == true) { +memcpy (dcb_table_ptr->tail_data, + (void *)app_in_address, data_in_size); + }else { +if (copy_from_user (dcb_table_ptr->tail_data, + (void __user *)app_in_address, + data_in_size)) { + error = -EFAULT ; + goto end_function; + } + } + + dcb_table_ptr->tail_data_size = data_in_size; + +/* Set the output user-space address for mem2mem op */ +if (app_out_address) + dcb_table_ptr->out_vr_tail_pt = + (aligned_u64 )app_out_address; + +/* +* Update both data length parameters in order to avoid +* second data copy and allow building of empty mlli +* tables +*/ + tail_size =0x0 ; + data_in_size =0x0 ; + + }else { +if (!app_out_address) { + tail_size = data_in_size % block_size; +if (!tail_size) { +if (tail_block_size == block_size) + tail_size = block_size; + } + }else { + tail_size =0 ; + } + } +if (tail_size) { +if (is_kva == true) { +memcpy (dcb_table_ptr->tail_data, + (void *)(app_in_address + data_in_size - + tail_size), tail_size); + }else { +/* We have tail data - copy it to DCB */ +if (copy_from_user (dcb_table_ptr->tail_data, + (void *)(app_in_address + + data_in_size - tail_size), tail_size)) { + error = -EFAULT ; + goto end_function; + } + } +if (app_out_address) +/* +* Calculate the output address +* according to tail data size +*/ + dcb_table_ptr->out_vr_tail_pt = + (aligned_u64 )app_out_address + data_in_size + - tail_size; + +/* Save the real tail data size */ + dcb_table_ptr->tail_data_size = tail_size; +/* +* Update the data size without the tail +* data size AKA data for the dma +*/ + data_in_size = (data_in_size - tail_size); + } + } +/* Check if we need to build only input table or input/output */ +if (app_out_address) { +/* Prepare input/output tables */ + error =sep_prepare_input_output_dma_table (sep, + app_in_address, + app_out_address, + data_in_size, + block_size, + &in_first_mlli_address, + &out_first_mlli_address, + &in_first_num_entries, + &out_first_num_entries, + &first_data_size, + is_kva); + }else { +/* Prepare input tables */ + error =sep_prepare_input_dma_table (sep, + app_in_address, + data_in_size, + block_size, + &in_first_mlli_address, + &in_first_num_entries, + &first_data_size, + is_kva); + } + +if (error) { +dev_warn (&sep->pdev->dev,"prepare DMA table call failed from prepare DCB call\n" ); + goto end_function; + } + +/* Set the DCB values */ + dcb_table_ptr->input_mlli_address = in_first_mlli_address; + dcb_table_ptr->input_mlli_num_entries = in_first_num_entries; + dcb_table_ptr->input_mlli_data_size = first_data_size; + dcb_table_ptr->output_mlli_address = out_first_mlli_address; + dcb_table_ptr->output_mlli_num_entries = out_first_num_entries; + dcb_table_ptr->output_mlli_data_size = first_data_size; + +end_function: +return error; + +} + +/** +* sep_free_dma_tables_and_dcb - free DMA tables and DCBs +* @sep: pointer to struct sep_device +* @isapplet: indicates external application (used for kernel access) +* @is_kva: indicates kernel addresses (only used for kernel crypto) +* +* This function frees the DMA tables and DCB +*/ +static int sep_free_dma_tables_and_dcb (struct sep_device *sep,bool isapplet, +bool is_kva) +{ +int i =0 ; +int error =0 ; +int error_temp =0 ; +struct sep_dcblock *dcb_table_ptr; +unsigned long pt_hold; +void *tail_pt; + +if (isapplet == true) { +/* Set pointer to first DCB table */ + dcb_table_ptr = (struct sep_dcblock *) + (sep->shared_addr + +SEP_DRIVER_SYSTEM_DCB_MEMORY_OFFSET_IN_BYTES ); + +/* Go over each DCB and see if tail pointer must be updated */ +for (i =0 ; i < sep->nr_dcb_creat; i++, dcb_table_ptr++) { +if (dcb_table_ptr->out_vr_tail_pt) { + pt_hold = (unsigned long )dcb_table_ptr->out_vr_tail_pt; + tail_pt = (void *)pt_hold; +if (is_kva == true) { +memcpy (tail_pt, + dcb_table_ptr->tail_data, + dcb_table_ptr->tail_data_size); + }else { + error_temp =copy_to_user ( + tail_pt, + dcb_table_ptr->tail_data, + dcb_table_ptr->tail_data_size); + } +if (error_temp) { +/* Release the DMA resource */ + error = -EFAULT ; +break ; + } + } + } + } +/* Free the output pages, if any */ +sep_free_dma_table_data_handler (sep); + +return error; +} + +/** +* sep_get_static_pool_addr_handler - get static pool address +* @sep: pointer to struct sep_device +* +* This function sets the bus and virtual addresses of the static pool +*/ +static int sep_get_static_pool_addr_handler (struct sep_device *sep) +{ +u32 *static_pool_addr =NULL ; + + static_pool_addr = (u32 *)(sep->shared_addr + +SEP_DRIVER_SYSTEM_RAR_MEMORY_OFFSET_IN_BYTES ); + + static_pool_addr[0 ] =SEP_STATIC_POOL_VAL_TOKEN ; + static_pool_addr[1 ] = (u32 )sep->shared_bus + +SEP_DRIVER_STATIC_AREA_OFFSET_IN_BYTES ; + +dev_dbg (&sep->pdev->dev,"static pool segment: physical %x\n" , + (u32 )static_pool_addr[1 ]); + +return 0 ; +} + +/** +* sep_end_transaction_handler - end transaction +* @sep: pointer to struct sep_device +* +* This API handles the end transaction request +*/ +static int sep_end_transaction_handler (struct sep_device *sep) +{ +/* Clear the data pool pointers Token */ +memset ((void *)(sep->shared_addr + +SEP_DRIVER_DATA_POOL_ALLOCATION_OFFSET_IN_BYTES ), +0 , sep->num_of_data_allocations*2 *sizeof (u32)); + +/* Check that all the DMA resources were freed */ +sep_free_dma_table_data_handler (sep); + +clear_bit (SEP_MMAP_LOCK_BIT , &sep->in_use_flags); + +/* +* We are now through with the transaction. Let's +* allow other processes who have the device open +* to perform transactions +*/ +mutex_lock (&sep->sep_mutex); + sep->pid_doing_transaction =0 ; +mutex_unlock (&sep->sep_mutex); +/* Raise event for stuck contextes */ +wake_up (&sep->event); + +return 0 ; +} + +/** +* sep_prepare_dcb_handler - prepare a control block +* @sep: pointer to struct sep_device +* @arg: pointer to user parameters +* +* This function will retrieve the RAR buffer physical addresses, type +* & size corresponding to the RAR handles provided in the buffers vector. +*/ +static int sep_prepare_dcb_handler (struct sep_device *sep,unsigned long arg) +{ +int error; +/* Command arguments */ +struct build_dcb_struct command_args; + +/* Get the command arguments */ +if (copy_from_user (&command_args, (void __user *)arg, +sizeof (struct build_dcb_struct ))) { + error = -EFAULT ; + goto end_function; + } + +dev_dbg (&sep->pdev->dev,"prep dcb handler app_in_address is %08llx\n" , + command_args.app_in_address); +dev_dbg (&sep->pdev->dev,"app_out_address is %08llx\n" , + command_args.app_out_address); +dev_dbg (&sep->pdev->dev,"data_size is %x\n" , + command_args.data_in_size); +dev_dbg (&sep->pdev->dev,"block_size is %x\n" , + command_args.block_size); +dev_dbg (&sep->pdev->dev,"tail block_size is %x\n" , + command_args.tail_block_size); + + error =sep_prepare_input_output_dma_table_in_dcb (sep, + (unsigned long )command_args.app_in_address, + (unsigned long )command_args.app_out_address, + command_args.data_in_size, command_args.block_size, + command_args.tail_block_size, true, false); + +end_function: +return error; + +} + +/** +* sep_free_dcb_handler - free control block resources +* @sep: pointer to struct sep_device +* +* This function frees the DCB resources and updates the needed +* user-space buffers. +*/ +static int sep_free_dcb_handler (struct sep_device *sep) +{ +return sep_free_dma_tables_and_dcb (sep, false, false); +} + +/** +* sep_rar_prepare_output_msg_handler - prepare an output message +* @sep: pointer to struct sep_device +* @arg: pointer to user parameters +* +* This function will retrieve the RAR buffer physical addresses, type +* & size corresponding to the RAR handles provided in the buffers vector. +*/ +static int sep_rar_prepare_output_msg_handler (struct sep_device *sep, +unsigned long arg) +{ +int error =0 ; +/* Command args */ +struct rar_hndl_to_bus_struct command_args; +/* Bus address */ +dma_addr_t rar_bus =0 ; +/* Holds the RAR address in the system memory offset */ +u32 *rar_addr; + +/* Copy the data */ +if (copy_from_user (&command_args, (void __user *)arg, +sizeof (command_args))) { + error = -EFAULT ; + goto end_function; + } + +/* Call to translation function only if user handle is not NULL */ +if (command_args.rar_handle) +return -EOPNOTSUPP ; +dev_dbg (&sep->pdev->dev,"rar msg; rar_addr_bus = %x\n" , (u32 )rar_bus); + +/* Set value in the SYSTEM MEMORY offset */ + rar_addr = (u32 *)(sep->shared_addr + +SEP_DRIVER_SYSTEM_RAR_MEMORY_OFFSET_IN_BYTES ); + +/* Copy the physical address to the System Area for the SEP */ + rar_addr[0 ] =SEP_RAR_VAL_TOKEN ; + rar_addr[1 ] = rar_bus; + +end_function: +return error; +} + +/** +* sep_ioctl - ioctl api +* @filp: pointer to struct file +* @cmd: command +* @arg: pointer to argument structure +* +* Implement the ioctl methods available on the SEP device. +*/ +static long sep_ioctl (struct file *filp,unsigned int cmd,unsigned long arg) +{ +int error =0 ; +struct sep_device *sep = filp->private_data; + +/* Make sure we own this device */ +mutex_lock (&sep->sep_mutex); +if ((current->pid != sep->pid_doing_transaction) && + (sep->pid_doing_transaction !=0 )) { +dev_dbg (&sep->pdev->dev,"ioctl pid is not owner\n" ); + error = -EACCES ; + goto end_function; + } + +mutex_unlock (&sep->sep_mutex); + +if (_IOC_TYPE (cmd) !=SEP_IOC_MAGIC_NUMBER ) +return -ENOTTY ; + +/* Lock to prevent the daemon to interfere with operation */ +mutex_lock (&sep->ioctl_mutex); + +switch (cmd) { +case SEP_IOCSENDSEPCOMMAND : +/* Send command to SEP */ + error =sep_send_command_handler (sep); +break ; +case SEP_IOCALLOCDATAPOLL : +/* Allocate data pool */ + error =sep_allocate_data_pool_memory_handler (sep, arg); +break ; +case SEP_IOCGETSTATICPOOLADDR : +/* Inform the SEP the bus address of the static pool */ + error =sep_get_static_pool_addr_handler (sep); +break ; +case SEP_IOCENDTRANSACTION : + error =sep_end_transaction_handler (sep); +break ; +case SEP_IOCRARPREPAREMESSAGE : + error =sep_rar_prepare_output_msg_handler (sep, arg); +break ; +case SEP_IOCPREPAREDCB : + error =sep_prepare_dcb_handler (sep, arg); +break ; +case SEP_IOCFREEDCB : + error =sep_free_dcb_handler (sep); +break ; +default : + error = -ENOTTY ; +break ; + } + +end_function: +mutex_unlock (&sep->ioctl_mutex); +return error; +} + +/** +* sep_singleton_ioctl - ioctl api for singleton interface +* @filp: pointer to struct file +* @cmd: command +* @arg: pointer to argument structure +* +* Implement the additional ioctls for the singleton device +*/ +static long sep_singleton_ioctl (struct file *filp,u32 cmd,unsigned long arg) +{ +long error =0 ; +struct sep_device *sep = filp->private_data; + +/* Check that the command is for the SEP device */ +if (_IOC_TYPE (cmd) !=SEP_IOC_MAGIC_NUMBER ) +return -ENOTTY ; + +/* Make sure we own this device */ +mutex_lock (&sep->sep_mutex); +if ((current->pid != sep->pid_doing_transaction) && + (sep->pid_doing_transaction !=0 )) { +dev_dbg (&sep->pdev->dev,"singleton ioctl pid is not owner\n" ); +mutex_unlock (&sep->sep_mutex); +return -EACCES ; + } + +mutex_unlock (&sep->sep_mutex); + +switch (cmd) { +case SEP_IOCTLSETCALLERID : +mutex_lock (&sep->ioctl_mutex); + error =sep_set_caller_id_handler (sep, arg); +mutex_unlock (&sep->ioctl_mutex); +break ; +default : + error =sep_ioctl (filp, cmd, arg); +break ; + } +return error; +} + +/** +* sep_request_daemon_ioctl - ioctl for daemon +* @filp: pointer to struct file +* @cmd: command +* @arg: pointer to argument structure +* +* Called by the request daemon to perform ioctls on the daemon device +*/ +static long sep_request_daemon_ioctl (struct file *filp,u32 cmd, +unsigned long arg) +{ + +long error; +struct sep_device *sep = filp->private_data; + +/* Check that the command is for SEP device */ +if (_IOC_TYPE (cmd) !=SEP_IOC_MAGIC_NUMBER ) +return -ENOTTY ; + +/* Only one process can access ioctl at any given time */ +mutex_lock (&sep->ioctl_mutex); + +switch (cmd) { +case SEP_IOCSENDSEPRPLYCOMMAND : +/* Send reply command to SEP */ + error =sep_req_daemon_send_reply_command_handler (sep); +break ; +case SEP_IOCENDTRANSACTION : +/* +* End req daemon transaction, do nothing +* will be removed upon update in middleware +* API library +*/ + error =0 ; +break ; +default : + error = -ENOTTY ; + } +mutex_unlock (&sep->ioctl_mutex); +return error; +} + +/** +* sep_inthandler - interrupt handler +* @irq: interrupt +* @dev_id: device id +*/ +static irqreturn_t sep_inthandler (int irq,void *dev_id) +{ +irqreturn_t int_error =IRQ_HANDLED ; +unsigned long lck_flags; +u32 reg_val, reg_val2 =0 ; +struct sep_device *sep = dev_id; + +/* Read the IRR register to check if this is SEP interrupt */ + reg_val =sep_read_reg (sep,HW_HOST_IRR_REG_ADDR ); + +if (reg_val & (0x1 <<13 )) { +/* Lock and update the counter of reply messages */ +spin_lock_irqsave (&sep->snd_rply_lck, lck_flags); + sep->reply_ct++; +spin_unlock_irqrestore (&sep->snd_rply_lck, lck_flags); + +dev_dbg (&sep->pdev->dev,"sep int: send_ct %lx reply_ct %lx\n" , + sep->send_ct, sep->reply_ct); + +/* Is this printf or daemon request? */ + reg_val2 =sep_read_reg (sep,HW_HOST_SEP_HOST_GPR2_REG_ADDR ); +dev_dbg (&sep->pdev->dev, +"SEP Interrupt - reg2 is %08x\n" , reg_val2); + +if ((reg_val2 >>30 ) &0x1 ) { +dev_dbg (&sep->pdev->dev,"int: printf request\n" ); +wake_up (&sep->event_request_daemon); + }else if (reg_val2 >>31 ) { +dev_dbg (&sep->pdev->dev,"int: daemon request\n" ); +wake_up (&sep->event_request_daemon); + }else { +dev_dbg (&sep->pdev->dev,"int: SEP reply\n" ); +wake_up (&sep->event); + } + }else { +dev_dbg (&sep->pdev->dev,"int: not SEP interrupt\n" ); + int_error =IRQ_NONE ; + } +if (int_error ==IRQ_HANDLED ) +sep_write_reg (sep,HW_HOST_ICR_REG_ADDR , reg_val); + +return int_error; +} + +/** +* sep_reconfig_shared_area - reconfigure shared area +* @sep: pointer to struct sep_device +* +* Reconfig the shared area between HOST and SEP - needed in case +* the DX_CC_Init function was called before OS loading. +*/ +static int sep_reconfig_shared_area (struct sep_device *sep) +{ +int ret_val; + +/* use to limit waiting for SEP */ +unsigned long end_time; + +/* Send the new SHARED MESSAGE AREA to the SEP */ +dev_dbg (&sep->pdev->dev,"reconfig shared; sending %08llx to sep\n" , + (unsigned long long )sep->shared_bus); + +sep_write_reg (sep,HW_HOST_HOST_SEP_GPR1_REG_ADDR , sep->shared_bus); + +/* Poll for SEP response */ + ret_val =sep_read_reg (sep,HW_HOST_SEP_HOST_GPR1_REG_ADDR ); + + end_time = jiffies + (WAIT_TIME *HZ ); + +while ((time_before (jiffies, end_time)) && (ret_val !=0xffffffff ) && + (ret_val != sep->shared_bus)) + ret_val =sep_read_reg (sep,HW_HOST_SEP_HOST_GPR1_REG_ADDR ); + +/* Check the return value (register) */ +if (ret_val != sep->shared_bus) { +dev_warn (&sep->pdev->dev,"could not reconfig shared area\n" ); +dev_warn (&sep->pdev->dev,"result was %x\n" , ret_val); + ret_val = -ENOMEM ; + }else + ret_val =0 ; + +dev_dbg (&sep->pdev->dev,"reconfig shared area end\n" ); +return ret_val; +} + +/* File operation for singleton SEP operations */ +static const struct file_operations singleton_file_operations = { + .owner =THIS_MODULE , + .unlocked_ioctl = sep_singleton_ioctl, + .poll = sep_poll, + .open = sep_singleton_open, + .release = sep_singleton_release, + .mmap = sep_mmap, +}; + +/* File operation for daemon operations */ +static const struct file_operations daemon_file_operations = { + .owner =THIS_MODULE , + .unlocked_ioctl = sep_request_daemon_ioctl, + .poll = sep_request_daemon_poll, + .open = sep_request_daemon_open, + .release = sep_request_daemon_release, + .mmap = sep_request_daemon_mmap, +}; + +/* The files operations structure of the driver */ +static const struct file_operations sep_file_operations = { + .owner =THIS_MODULE , + .unlocked_ioctl = sep_ioctl, + .poll = sep_poll, + .open = sep_open, + .release = sep_release, + .mmap = sep_mmap, +}; + +/** +* sep_register_driver_with_fs - register misc devices +* @sep: pointer to struct sep_device +* +* This function registers the driver with the file system +*/ +static int sep_register_driver_with_fs (struct sep_device *sep) +{ +int ret_val; + + sep->miscdev_sep.minor =MISC_DYNAMIC_MINOR ; + sep->miscdev_sep.name =SEP_DEV_NAME ; + sep->miscdev_sep.fops = &sep_file_operations; + + sep->miscdev_singleton.minor =MISC_DYNAMIC_MINOR ; + sep->miscdev_singleton.name =SEP_DEV_SINGLETON ; + sep->miscdev_singleton.fops = &singleton_file_operations; + + sep->miscdev_daemon.minor =MISC_DYNAMIC_MINOR ; + sep->miscdev_daemon.name =SEP_DEV_DAEMON ; + sep->miscdev_daemon.fops = &daemon_file_operations; + + ret_val =misc_register (&sep->miscdev_sep); +if (ret_val) { +dev_warn (&sep->pdev->dev,"misc reg fails for SEP %x\n" , + ret_val); +return ret_val; + } + + ret_val =misc_register (&sep->miscdev_singleton); +if (ret_val) { +dev_warn (&sep->pdev->dev,"misc reg fails for sing %x\n" , + ret_val); +misc_deregister (&sep->miscdev_sep); +return ret_val; + } + + ret_val =misc_register (&sep->miscdev_daemon); +if (ret_val) { +dev_warn (&sep->pdev->dev,"misc reg fails for dmn %x\n" , + ret_val); +misc_deregister (&sep->miscdev_sep); +misc_deregister (&sep->miscdev_singleton); + +return ret_val; + } +return ret_val; +} + + +/** +* sep_probe - probe a matching PCI device +* @pdev: pci_device +* @end: pci_device_id +* +* Attempt to set up and configure a SEP device that has been +* discovered by the PCI layer. +*/ +static int __devinit sep_probe (struct pci_dev *pdev, +const struct pci_device_id *ent) +{ +int error =0 ; +struct sep_device *sep; + +if (sep_dev !=NULL ) { +dev_warn (&pdev->dev,"only one SEP supported.\n" ); +return -EBUSY ; + } + +/* Enable the device */ + error =pci_enable_device (pdev); +if (error) { +dev_warn (&pdev->dev,"error enabling pci device\n" ); + goto end_function; + } + +/* Allocate the sep_device structure for this device */ + sep_dev =kzalloc (sizeof (struct sep_device ),GFP_ATOMIC ); +if (sep_dev ==NULL ) { +dev_warn (&pdev->dev, +"can't kmalloc the sep_device structure\n" ); + error = -ENOMEM ; + goto end_function_disable_device; + } + +/* +* We're going to use another variable for actually +* working with the device; this way, if we have +* multiple devices in the future, it would be easier +* to make appropriate changes +*/ + sep = sep_dev; + + sep->pdev =pci_dev_get (pdev); + +init_waitqueue_head (&sep->event); +init_waitqueue_head (&sep->event_request_daemon); +spin_lock_init (&sep->snd_rply_lck); +mutex_init (&sep->sep_mutex); +mutex_init (&sep->ioctl_mutex); + +dev_dbg (&sep->pdev->dev,"sep probe: PCI obtained, device being prepared\n" ); +dev_dbg (&sep->pdev->dev,"revision is %d\n" , sep->pdev->revision); + +/* Set up our register area */ + sep->reg_physical_addr =pci_resource_start (sep->pdev,0 ); +if (!sep->reg_physical_addr) { +dev_warn (&sep->pdev->dev,"Error getting register start\n" ); + error = -ENODEV ; + goto end_function_free_sep_dev; + } + + sep->reg_physical_end =pci_resource_end (sep->pdev,0 ); +if (!sep->reg_physical_end) { +dev_warn (&sep->pdev->dev,"Error getting register end\n" ); + error = -ENODEV ; + goto end_function_free_sep_dev; + } + + sep->reg_addr =ioremap_nocache (sep->reg_physical_addr, + (size_t )(sep->reg_physical_end - sep->reg_physical_addr +1 )); +if (!sep->reg_addr) { +dev_warn (&sep->pdev->dev,"Error getting register virtual\n" ); + error = -ENODEV ; + goto end_function_free_sep_dev; + } + +dev_dbg (&sep->pdev->dev, +"Register area start %llx end %llx virtual %p\n" , + (unsigned long long )sep->reg_physical_addr, + (unsigned long long )sep->reg_physical_end, + sep->reg_addr); + +/* Allocate the shared area */ + sep->shared_size =SEP_DRIVER_MESSAGE_SHARED_AREA_SIZE_IN_BYTES + +SYNCHRONIC_DMA_TABLES_AREA_SIZE_BYTES + +SEP_DRIVER_DATA_POOL_SHARED_AREA_SIZE_IN_BYTES + +SEP_DRIVER_STATIC_AREA_SIZE_IN_BYTES + +SEP_DRIVER_SYSTEM_DATA_MEMORY_SIZE_IN_BYTES ; + +if (sep_map_and_alloc_shared_area (sep)) { + error = -ENOMEM ; +/* Allocation failed */ + goto end_function_error; + } + +/* Clear ICR register */ +sep_write_reg (sep,HW_HOST_ICR_REG_ADDR ,0xFFFFFFFF ); + +/* Set the IMR register - open only GPR 2 */ +sep_write_reg (sep,HW_HOST_IMR_REG_ADDR , (~(0x1 <<13 ))); + +/* Read send/receive counters from SEP */ + sep->reply_ct =sep_read_reg (sep,HW_HOST_SEP_HOST_GPR2_REG_ADDR ); + sep->reply_ct &=0x3FFFFFFF ; + sep->send_ct = sep->reply_ct; + +/* Get the interrupt line */ + error =request_irq (pdev->irq, sep_inthandler,IRQF_SHARED , +"sep_driver" , sep); + +if (error) + goto end_function_deallocate_sep_shared_area; + +/* The new chip requires a shared area reconfigure */ +if (sep->pdev->revision ==4 ) {/* Only for new chip */ + error =sep_reconfig_shared_area (sep); +if (error) + goto end_function_free_irq; + } +/* Finally magic up the device nodes */ +/* Register driver with the fs */ + error =sep_register_driver_with_fs (sep); +if (error ==0 ) +/* Success */ +return 0 ; + +end_function_free_irq: +free_irq (pdev->irq, sep); + +end_function_deallocate_sep_shared_area: +/* De-allocate shared area */ +sep_unmap_and_free_shared_area (sep); + +end_function_error:Lines of this file are not shown. View the raw message.
drivers/misc/sep/sep_driver_api.h new file +215
-0Lines of this file are not shown. View the raw message.
drivers/misc/sep/sep_driver_config.h new file +243
-0Lines of this file are not shown. View the raw message.
drivers/misc/sep/sep_driver_hw_defs.h new file +233
-0Lines of this file are not shown. View the raw message.
drivers/staging/sep/sep_dev.h deleted +0
-131Lines of this file are not shown. View the raw message.
drivers/staging/sep/sep_driver.c deleted +0
-1073Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
lli_array[%x].block_size is %x\n",
drivers/staging/sep/sep_driver.c deleted +0
-1855Lines of this file are not shown. View the raw message.
drivers/staging/sep/sep_driver_api.h deleted +0
-215Lines of this file are not shown. View the raw message.
drivers/staging/sep/sep_driver_config.h deleted +0
-243Lines of this file are not shown. View the raw message.
drivers/staging/sep/sep_driver_hw_defs.h deleted +0
-234Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
1.7.0.4
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Part of the diff is not shown here. View the raw message.
Quoted 5 lines · Joseph
Quoted 5 lines
From: [email protected] [mailto:[email protected]] On Behalf Of Mark Allyn
Sent: Friday, April 22, 2011 1:51 PMSigned-off-by Mark Allyn <[email protected]>
Nope, not yet, see my other comments about this driver.
thanks,
greg k-h
Quoted 30 lines
Quoted 30 lines
--- drivers/misc/Kconfig | 1 + drivers/misc/Makefile | 1 + drivers/misc/sep/Kconfig | 10 + drivers/misc/sep/Makefile | 2 + drivers/misc/sep/TODO | 4 + drivers/misc/sep/sep_dev.h | 131 ++ drivers/misc/sep/sep_driver.c | 2928 ++++++++++++++++++++++++++++++ drivers/misc/sep/sep_driver_api.h | 215 +++ drivers/misc/sep/sep_driver_config.h | 243 +++ drivers/misc/sep/sep_driver_hw_defs.h | 233 +++ drivers/staging/Kconfig | 2 - drivers/staging/Makefile | 1 - drivers/staging/sep/Kconfig | 10 - drivers/staging/sep/Makefile | 2 - drivers/staging/sep/TODO | 4 - drivers/staging/sep/sep_dev.h | 131 -- drivers/staging/sep/sep_driver.c | 2928 ------------------------------ drivers/staging/sep/sep_driver_api.h | 215 --- drivers/staging/sep/sep_driver_config.h | 243 --- drivers/staging/sep/sep_driver_hw_defs.h | 233 --- 20 files changed, 3768 insertions(+), 3769 deletions(-) create mode 100644 drivers/misc/sep/Kconfig create mode 100644 drivers/misc/sep/Makefile create mode 100644 drivers/misc/sep/TODO create mode 100644 drivers/misc/sep/sep_dev.h create mode 100644 drivers/misc/sep/sep_driver.c create mode 100644 drivers/misc/sep/sep_driver_api.h create mode 100644 drivers/misc/sep/sep_driver_config.h create mode 100644 drivers/misc/sep/sep_driver_hw_defs.h
Quoted 8 lines
Quoted 8 lines
delete mode 100644 drivers/staging/sep/Kconfig delete mode 100644 drivers/staging/sep/Makefile delete mode 100644 drivers/staging/sep/TODO delete mode 100644 drivers/staging/sep/sep_dev.h delete mode 100644 drivers/staging/sep/sep_driver.c delete mode 100644 drivers/staging/sep/sep_driver_api.h delete mode 100644 drivers/staging/sep/sep_driver_config.h delete mode 100644 drivers/staging/sep/sep_driver_hw_defs.h
Next time you do this, do so using git so we can be sure that you really did just move the files and nothing changed. I can handle patches generated that way (i.e. renames).
thanks,
greg k-h