linux/drivers/staging/sep/sep_driver_api.h
<<
>>
Prefs
   1/*
   2 *
   3 *  sep_driver_api.h - Security Processor Driver api definitions
   4 *
   5 *  Copyright(c) 2009-2011 Intel Corporation. All rights reserved.
   6 *  Contributions(c) 2009-2011 Discretix. All rights reserved.
   7 *
   8 *  This program is free software; you can redistribute it and/or modify it
   9 *  under the terms of the GNU General Public License as published by the Free
  10 *  Software Foundation; version 2 of the License.
  11 *
  12 *  This program is distributed in the hope that it will be useful, but WITHOUT
  13 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15 *  more details.
  16 *
  17 *  You should have received a copy of the GNU General Public License along with
  18 *  this program; if not, write to the Free Software Foundation, Inc., 59
  19 *  Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20 *
  21 *  CONTACTS:
  22 *
  23 *  Mark Allyn          mark.a.allyn@intel.com
  24 *  Jayant Mangalampalli jayant.mangalampalli@intel.com
  25 *
  26 *  CHANGES:
  27 *
  28 *  2010.09.14  Upgrade to Medfield
  29 *  2011.02.22  Enable kernel crypto
  30 *
  31 */
  32
  33#ifndef __SEP_DRIVER_API_H__
  34#define __SEP_DRIVER_API_H__
  35
  36/* Type of request from device */
  37#define SEP_DRIVER_SRC_REPLY            1
  38#define SEP_DRIVER_SRC_REQ              2
  39#define SEP_DRIVER_SRC_PRINTF           3
  40
  41/* Power state */
  42#define SEP_DRIVER_POWERON              1
  43#define SEP_DRIVER_POWEROFF             2
  44
  45/* Following enums are used only for kernel crypto api */
  46enum type_of_request {
  47        NO_REQUEST,
  48        AES_CBC,
  49        AES_ECB,
  50        DES_CBC,
  51        DES_ECB,
  52        DES3_ECB,
  53        DES3_CBC,
  54        SHA1,
  55        MD5,
  56        SHA224,
  57        SHA256
  58        };
  59
  60enum hash_stage {
  61        HASH_INIT,
  62        HASH_UPDATE,
  63        HASH_FINISH,
  64        HASH_DIGEST,
  65        HASH_FINUP_DATA,
  66        HASH_FINUP_FINISH
  67};
  68
  69/*
  70  structure that represents DCB
  71*/
  72struct sep_dcblock {
  73        /* physical address of the first input mlli */
  74        u32     input_mlli_address;
  75        /* num of entries in the first input mlli */
  76        u32     input_mlli_num_entries;
  77        /* size of data in the first input mlli */
  78        u32     input_mlli_data_size;
  79        /* physical address of the first output mlli */
  80        u32     output_mlli_address;
  81        /* num of entries in the first output mlli */
  82        u32     output_mlli_num_entries;
  83        /* size of data in the first output mlli */
  84        u32     output_mlli_data_size;
  85        /* pointer to the output virtual tail */
  86        aligned_u64 out_vr_tail_pt;
  87        /* size of tail data */
  88        u32     tail_data_size;
  89        /* input tail data array */
  90        u8      tail_data[68];
  91};
  92
  93/*
  94        command structure for building dcb block (currently for ext app only)
  95*/
  96struct build_dcb_struct {
  97        /* address value of the data in */
  98        aligned_u64 app_in_address;
  99        /* size of data in */
 100        u32  data_in_size;
 101        /* address of the data out */
 102        aligned_u64 app_out_address;
 103        /* the size of the block of the operation - if needed,
 104        every table will be modulo this parameter */
 105        u32  block_size;
 106        /* the size of the block of the operation - if needed,
 107        every table will be modulo this parameter */
 108        u32  tail_block_size;
 109
 110        /* which application calls the driver DX or applet */
 111        u32  is_applet;
 112};
 113
 114/*
 115        command structure for building dcb block for kernel crypto
 116*/
 117struct build_dcb_struct_kernel {
 118        /* address value of the data in */
 119        void *app_in_address;
 120        /* size of data in */
 121        ssize_t  data_in_size;
 122        /* address of the data out */
 123        void *app_out_address;
 124        /* the size of the block of the operation - if needed,
 125        every table will be modulo this parameter */
 126        u32  block_size;
 127        /* the size of the block of the operation - if needed,
 128        every table will be modulo this parameter */
 129        u32  tail_block_size;
 130
 131        /* which application calls the driver DX or applet */
 132        u32  is_applet;
 133
 134        struct scatterlist *src_sg;
 135        struct scatterlist *dst_sg;
 136};
 137
 138/**
 139 * @struct sep_dma_map
 140 *
 141 * Structure that contains all information needed for mapping the user pages
 142 *           or kernel buffers for dma operations
 143 *
 144 *
 145 */
 146struct sep_dma_map {
 147        /* mapped dma address */
 148        dma_addr_t    dma_addr;
 149        /* size of the mapped data */
 150        size_t        size;
 151};
 152
 153struct sep_dma_resource {
 154        /* array of pointers to the pages that represent
 155        input data for the synchronic DMA action */
 156        struct page **in_page_array;
 157
 158        /* array of pointers to the pages that represent out
 159        data for the synchronic DMA action */
 160        struct page **out_page_array;
 161
 162        /* number of pages in the sep_in_page_array */
 163        u32 in_num_pages;
 164
 165        /* number of pages in the sep_out_page_array */
 166        u32 out_num_pages;
 167
 168        /* map array of the input data */
 169        struct sep_dma_map *in_map_array;
 170
 171        /* map array of the output data */
 172        struct sep_dma_map *out_map_array;
 173
 174        /* number of entries of the input mapp array */
 175        u32 in_map_num_entries;
 176
 177        /* number of entries of the output mapp array */
 178        u32 out_map_num_entries;
 179
 180        /* Scatter list for kernel operations */
 181        struct scatterlist *src_sg;
 182        struct scatterlist *dst_sg;
 183};
 184
 185
 186/* command struct for translating rar handle to bus address
 187   and setting it at predefined location */
 188struct rar_hndl_to_bus_struct {
 189
 190        /* rar handle */
 191        aligned_u64 rar_handle;
 192};
 193
 194/*
 195  structure that represent one entry in the DMA LLI table
 196*/
 197struct sep_lli_entry {
 198        /* physical address */
 199        u32 bus_address;
 200
 201        /* block size */
 202        u32 block_size;
 203};
 204
 205/*
 206 * header format for each fastcall write operation
 207 */
 208struct sep_fastcall_hdr {
 209        u32 magic;
 210        u32 secure_dma;
 211        u32 msg_len;
 212        u32 num_dcbs;
 213};
 214
 215/*
 216 * structure used in file pointer's private data field
 217 * to track the status of the calls to the various
 218 * driver interface
 219 */
 220struct sep_call_status {
 221        unsigned long status;
 222};
 223
 224/*
 225 * format of dma context buffer used to store all DMA-related
 226 * context information of a particular transaction
 227 */
 228struct sep_dma_context {
 229        /* number of data control blocks */
 230        u32 nr_dcb_creat;
 231        /* number of the lli tables created in the current transaction */
 232        u32 num_lli_tables_created;
 233        /* size of currently allocated dma tables region */
 234        u32 dmatables_len;
 235        /* size of input data */
 236        u32 input_data_len;
 237        /* secure dma use (for imr memory restricted area in output) */
 238        bool secure_dma;
 239        struct sep_dma_resource dma_res_arr[SEP_MAX_NUM_SYNC_DMA_OPS];
 240        /* Scatter gather for kernel crypto */
 241        struct scatterlist *src_sg;
 242        struct scatterlist *dst_sg;
 243};
 244
 245/*
 246 * format for file pointer's private_data field
 247 */
 248struct sep_private_data {
 249        struct sep_queue_info *my_queue_elem;
 250        struct sep_device *device;
 251        struct sep_call_status call_status;
 252        struct sep_dma_context *dma_ctx;
 253};
 254
 255
 256/* Functions used by sep_crypto */
 257
 258/**
 259 * sep_queue_status_remove - Removes transaction from status queue
 260 * @sep: SEP device
 261 * @sep_queue_info: pointer to status queue
 262 *
 263 * This function will removes information about transaction from the queue.
 264 */
 265void sep_queue_status_remove(struct sep_device *sep,
 266                                      struct sep_queue_info **queue_elem);
 267/**
 268 * sep_queue_status_add - Adds transaction to status queue
 269 * @sep: SEP device
 270 * @opcode: transaction opcode
 271 * @size: input data size
 272 * @pid: pid of current process
 273 * @name: current process name
 274 * @name_len: length of name (current process)
 275 *
 276 * This function adds information about about transaction started to the status
 277 * queue.
 278 */
 279struct sep_queue_info *sep_queue_status_add(
 280                                                struct sep_device *sep,
 281                                                u32 opcode,
 282                                                u32 size,
 283                                                u32 pid,
 284                                                u8 *name, size_t name_len);
 285
 286/**
 287 *      sep_create_dcb_dmatables_context_kernel - Creates DCB & MLLI/DMA table context
 288 *      for kernel crypto
 289 *      @sep: SEP device
 290 *      @dcb_region: DCB region buf to create for current transaction
 291 *      @dmatables_region: MLLI/DMA tables buf to create for current transaction
 292 *      @dma_ctx: DMA context buf to create for current transaction
 293 *      @user_dcb_args: User arguments for DCB/MLLI creation
 294 *      @num_dcbs: Number of DCBs to create
 295 */
 296int sep_create_dcb_dmatables_context_kernel(struct sep_device *sep,
 297                        struct sep_dcblock **dcb_region,
 298                        void **dmatables_region,
 299                        struct sep_dma_context **dma_ctx,
 300                        const struct build_dcb_struct_kernel *dcb_data,
 301                        const u32 num_dcbs);
 302
 303/**
 304 *      sep_activate_dcb_dmatables_context - Takes DCB & DMA tables
 305 *                                              contexts into use
 306 *      @sep: SEP device
 307 *      @dcb_region: DCB region copy
 308 *      @dmatables_region: MLLI/DMA tables copy
 309 *      @dma_ctx: DMA context for current transaction
 310 */
 311ssize_t sep_activate_dcb_dmatables_context(struct sep_device *sep,
 312                                        struct sep_dcblock **dcb_region,
 313                                        void **dmatables_region,
 314                                        struct sep_dma_context *dma_ctx);
 315
 316/**
 317 * sep_prepare_input_output_dma_table_in_dcb - prepare control blocks
 318 * @app_in_address: unsigned long; for data buffer in (user space)
 319 * @app_out_address: unsigned long; for data buffer out (user space)
 320 * @data_in_size: u32; for size of data
 321 * @block_size: u32; for block size
 322 * @tail_block_size: u32; for size of tail block
 323 * @isapplet: bool; to indicate external app
 324 * @is_kva: bool; kernel buffer; only used for kernel crypto module
 325 * @secure_dma; indicates whether this is secure_dma using IMR
 326 *
 327 * This function prepares the linked DMA tables and puts the
 328 * address for the linked list of tables inta a DCB (data control
 329 * block) the address of which is known by the SEP hardware
 330 * Note that all bus addresses that are passed to the SEP
 331 * are in 32 bit format; the SEP is a 32 bit device
 332 */
 333int sep_prepare_input_output_dma_table_in_dcb(struct sep_device *sep,
 334        unsigned long  app_in_address,
 335        unsigned long  app_out_address,
 336        u32  data_in_size,
 337        u32  block_size,
 338        u32  tail_block_size,
 339        bool isapplet,
 340        bool    is_kva,
 341        bool    secure_dma,
 342        struct sep_dcblock *dcb_region,
 343        void **dmatables_region,
 344        struct sep_dma_context **dma_ctx,
 345        struct scatterlist *src_sg,
 346        struct scatterlist *dst_sg);
 347
 348/**
 349 * sep_free_dma_table_data_handler - free DMA table
 350 * @sep: pointer to struct sep_device
 351 * @dma_ctx: dma context
 352 *
 353 * Handles the request to free DMA table for synchronic actions
 354 */
 355int sep_free_dma_table_data_handler(struct sep_device *sep,
 356                                           struct sep_dma_context **dma_ctx);
 357/**
 358 * sep_send_command_handler - kick off a command
 359 * @sep: SEP being signalled
 360 *
 361 * This function raises interrupt to SEP that signals that is has a new
 362 * command from the host
 363 *
 364 * Note that this function does fall under the ioctl lock
 365 */
 366int sep_send_command_handler(struct sep_device *sep);
 367
 368/**
 369 *      sep_wait_transaction - Used for synchronizing transactions
 370 *      @sep: SEP device
 371 */
 372int sep_wait_transaction(struct sep_device *sep);
 373
 374/**
 375 * IOCTL command defines
 376 */
 377/* magic number 1 of the sep IOCTL command */
 378#define SEP_IOC_MAGIC_NUMBER    's'
 379
 380/* sends interrupt to sep that message is ready */
 381#define SEP_IOCSENDSEPCOMMAND    \
 382        _IO(SEP_IOC_MAGIC_NUMBER, 0)
 383
 384/* end transaction command */
 385#define SEP_IOCENDTRANSACTION    \
 386        _IO(SEP_IOC_MAGIC_NUMBER, 15)
 387
 388#define SEP_IOCPREPAREDCB                                       \
 389        _IOW(SEP_IOC_MAGIC_NUMBER, 35, struct build_dcb_struct)
 390
 391#define SEP_IOCFREEDCB                                  \
 392        _IO(SEP_IOC_MAGIC_NUMBER, 36)
 393
 394struct sep_device;
 395
 396#define SEP_IOCPREPAREDCB_SECURE_DMA    \
 397        _IOW(SEP_IOC_MAGIC_NUMBER, 38, struct build_dcb_struct)
 398
 399#define SEP_IOCFREEDCB_SECURE_DMA       \
 400        _IO(SEP_IOC_MAGIC_NUMBER, 39)
 401
 402#endif
 403