drivers/staging/sep/sep_dev.h

   1 #ifndef __SEP_DEV_H__
   2 #define __SEP_DEV_H__
   3
   4 /*
   5  *
   6  *  sep_dev.h - Security Processor Device Structures
   7  *
   8  *  Copyright(c) 2009-2011 Intel Corporation. All rights reserved.
   9  *  Contributions(c) 2009-2011 Discretix. All rights reserved.
  10  *
  11  *  This program is free software; you can redistribute it and/or modify it
  12  *  under the terms of the GNU General Public License as published by the Free
  13  *  Software Foundation; version 2 of the License.
  14  *
  15  *  This program is distributed in the hope that it will be useful, but WITHOUT
  16  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  18  *  more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License along with
  21  *  this program; if not, write to the Free Software Foundation, Inc., 59
  22  *  Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  *
  24  *  CONTACTS:
  25  *
  26  *  Mark Allyn          mark.a.allyn@intel.com
  27  *  Jayant Mangalampalli jayant.mangalampalli@intel.com
  28  *
  29  *  CHANGES
  30  *  2010.09.14  upgrade to Medfield
  31  *  2011.02.22  enable kernel crypto
  32  */
  33
  34 struct sep_device {
  35         /* pointer to pci dev */
  36         struct pci_dev *pdev;
  37
  38         /* character device file */
  39         struct cdev sep_cdev;
  40
  41         /* devices (using misc dev) */
  42         struct miscdevice miscdev_sep;
  43
  44         /* major / minor numbers of device */
  45         dev_t sep_devno;
  46         /* guards command sent counter */
  47         spinlock_t snd_rply_lck;
  48         /* guards driver memory usage in fastcall if */
  49         struct semaphore sep_doublebuf;
  50
  51         /* flags to indicate use and lock status of sep */
  52         u32 pid_doing_transaction;
  53         unsigned long in_use_flags;
  54
  55         /* address of the shared memory allocated during init for SEP driver
  56            (coherent alloc) */
  57         dma_addr_t shared_bus;
  58         size_t shared_size;
  59         void *shared_addr;
  60
  61         /* start address of the access to the SEP registers from driver */
  62         dma_addr_t reg_physical_addr;
  63         dma_addr_t reg_physical_end;
  64         void __iomem *reg_addr;
  65
  66         /* wait queue heads of the driver */
  67         wait_queue_head_t event_interrupt;
  68         wait_queue_head_t event_transactions;
  69
  70         struct list_head sep_queue_status;
  71         u32 sep_queue_num;
  72         spinlock_t sep_queue_lock;
  73
  74         /* Is this in use? */
  75         u32 in_use;
  76
  77         /* indicates whether power save is set up */
  78         u32 power_save_setup;
  79
  80         /* Power state */
  81         u32 power_state;
  82
  83         /* transaction counter that coordinates the
  84            transactions between SEP and HOST */
  85         unsigned long send_ct;
  86         /* counter for the messages from sep */
  87         unsigned long reply_ct;
  88
  89         /* The following are used for kernel crypto client requests */
  90         u32 in_kernel; /* Set for kernel client request */
  91         struct tasklet_struct   finish_tasklet;
  92         enum type_of_request current_request;
  93         enum hash_stage current_hash_stage;
  94         struct ahash_request    *current_hash_req;
  95         struct ablkcipher_request *current_cypher_req;
  96         struct this_task_ctx *ta_ctx;
  97         struct workqueue_struct *workqueue;
  98 };
  99
 100 extern struct sep_device *sep_dev;
 101
 102 /**
 103  * SEP message header for a transaction
 104  * @reserved: reserved memory (two words)
 105  * @token: SEP message token
 106  * @msg_len: message length
 107  * @opcpde: message opcode
 108  */
 109 struct sep_msgarea_hdr {
 110         u32 reserved[2];
 111         u32 token;
 112         u32 msg_len;
 113         u32 opcode;
 114 };
 115
 116 /**
 117  * sep_queue_data - data to be maintained in status queue for a transaction
 118  * @opcode : transaction opcode
 119  * @size : message size
 120  * @pid: owner process
 121  * @name: owner process name
 122  */
 123 struct sep_queue_data {
 124         u32 opcode;
 125         u32 size;
 126         s32 pid;
 127         u8 name[TASK_COMM_LEN];
 128 };
 129
 130 /** sep_queue_info - maintains status info of all transactions
 131  * @list: head of list
 132  * @sep_queue_data : data for transaction
 133  */
 134 struct sep_queue_info {
 135         struct list_head list;
 136         struct sep_queue_data data;
 137 };
 138
 139 static inline void sep_write_reg(struct sep_device *dev, int reg, u32 value)
 140 {
 141         void __iomem *addr = dev->reg_addr + reg;
 142         writel(value, addr);
 143 }
 144
 145 static inline u32 sep_read_reg(struct sep_device *dev, int reg)
 146 {
 147         void __iomem *addr = dev->reg_addr + reg;
 148         return readl(addr);
 149 }
 150
 151 /* wait for SRAM write complete(indirect write */
 152 static inline void sep_wait_sram_write(struct sep_device *dev)
 153 {
 154         u32 reg_val;
 155         do {
 156                 reg_val = sep_read_reg(dev, HW_SRAM_DATA_READY_REG_ADDR);
 157         } while (!(reg_val & 1));
 158 }
 159
 160
 161 #endif