axis_pci.h

Go to the documentation of this file.

/***************************************************************************
*
*     Axis 2 PCI Linux Kernel driver
*     File:    axis_pci.h
*     Version: 1.0
*     Copyright 2004 Heber Limited (http://www.heber.co.uk)
*
*     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; either version 2, or (at your option) any
*     later version.
*
*     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.,
*     675 Mass Ave, Cambridge, MA 02139, USA.
*
*     Changes:
*
****************************************************************************/
#ifndef AXIS_PCI_H
#define AXIS_PCI_H
#ifndef _LINUX_KERNEL_H

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/version.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/delay.h>
#include <linux/pci.h>
#include <linux/list.h>
#include <linux/ioport.h>
#include <linux/serial.h>
#include <linux/interrupt.h>
#include <linux/string.h>
#include <linux/spinlock.h>
#include <linux/mtd/mtd.h>
#include <linux/crypto.h>
#include <asm/uaccess.h>

#endif  //_LINUX_KERNEL_H
#ifndef AXIS_HARDWARE_H
    #include "axis_hardware.h"
#endif //AXIS_HARDWARE_H

#ifndef AXIS_SPI_IO_H
    #include "spi_io.h"
#endif

#ifndef AXIS_PARALLEL_IO_H
    #include "parallel_io.h"
#endif

#ifndef AXIS_SERIAL_IO_H
    #include "serial_io.h"
#endif


#ifndef AXIS_DES_IO_H
    #include "des_io.h"
#endif

#ifndef AXIS_W1_H
    #include "axis_w1.h"
#endif
//Lift and hack one of the inline functions from include/linux/proc_fs.h
static inline struct proc_dir_entry *create_proc_read_write_entry(const char *name,
        mode_t mode, struct proc_dir_entry *base,
        read_proc_t *read_proc,write_proc_t *write_proc, void * data)
{
        struct proc_dir_entry *res=create_proc_entry(name,mode,base);
        if (res) {
                res->read_proc=read_proc;
                res->write_proc=write_proc ;
                res->data=data;
        }
        return res;
}

struct axis_region
{
    unsigned long start_address ;           
    void * remapped_address ;               
    unsigned long length ;                  
    int is_memory_region ;                  
    int present     ;                       
} ;

//Pre declare axis_pci_device_entry this as we have a circular dependency
struct axis_pci_device_entry ;
struct axis_component_instance
{
    struct axis_pci_device_entry * this_device ;    
    int subdevice_number ;                          
};

struct axis_pci_device_entry
{
    struct list_head list;                          
    atomic_t smart_card_open_count ;                
    wait_queue_head_t des_key_queue             ;   
    wait_queue_head_t des_channel_queue ;           
    wait_queue_head_t spi_op_queue ;                
    wait_queue_head_t spi_interrupt_queue ;         
    wait_queue_head_t smart_card_tx_interrupt_queue ; 
    wait_queue_head_t smart_card_rx_interrupt_queue ; 
    unsigned char smart_card_rx_buffer[64];         
    unsigned char smart_card_tx_buffer[64];         
    volatile unsigned char * smart_card_tx_head ;   
    volatile unsigned char * smart_card_tx_tail ;   
    volatile unsigned char * smart_card_rx_head ;   
    volatile unsigned char * smart_card_rx_tail ;   
    volatile unsigned long rx_start_wait_time   ;   
    unsigned long smart_card_rx_timeout;            
    long smart_card_minimum_inter_char_time; 
    atomic_t smart_card_tx_finished ;               
    atomic_t smart_card_tx_active ;                 
    atomic_t spi_finished ;                         
    atomic_t spi_active   ;
    struct semaphore output_lock ;                  
    struct semaphore input_lock ;                   
    struct semaphore serial_lock ;                  
    struct semaphore des_security_lock ;            
    struct semaphore des_key_lock ;                 
    struct semaphore des_channel_lock ;             
    struct semaphore spi_lock ;                     
    pid_t   thread_pid;                             
    unsigned long thread_delay ;                    
    struct completion thread_exited ;               
    struct pci_dev * dev ;                          
    unsigned long route_register;                   
    int device_number    ;                          
    unsigned int last_uart ;                        
    unsigned long parallel_control_mirror ;         
    void * interrupt_dev_id ;                       
    int uart_idents[AXIS_MAX_UARTS];                
    struct spi_channel spi_channels[MAX_AXIS_SPI_DEVICES];  
    struct axis_des_hardware_key des_hardware_keys[NUMBER_OF_KEY_STORES];
    struct axis_des_hardware_channel des_channels[NUMBER_OF_DES_CHANNELS];
    struct axis_region regions[MAX_AXIS_REGIONS] ;  
    struct axis_component_instance  sub_devices[AXIS_MAX_SUB_DEVICES] ; 
    struct axis_io_bitmap * io_bitmap ;             
    struct proc_dir_entry * proc_root_directory ;   
    struct proc_dir_entry * proc_inputs_directory ;     
    struct proc_dir_entry * proc_outputs_directory ;    
    struct proc_dir_entry * proc_serial_directory ;     
    struct proc_dir_entry * proc_dipswitch_directory;   
    struct proc_dir_entry * proc_sram_directory;        
    struct axis_des_hardware_channel des_key_channel ;  
    struct list_head ram_partition_list ;           
    struct axis_w1 silicon_serial_number ;
    struct axis_w1 ibutton ;

} ;

static inline void enable_pci_interrupts(struct axis_pci_device_entry * device)
{
    writel(INTERRUPT_SETUP,device->regions[0].remapped_address+INTERRUPT_CONTROL_REGISTER);
}

static inline void disable_pci_interrupts(struct axis_pci_device_entry * device)
{
    writel(0,device->regions[0].remapped_address+INTERRUPT_CONTROL_REGISTER);
}

struct axis_pci_device_entry * choose_device(struct inode * inode_ptr ,struct file * file_ptr);
struct axis_pci_device_entry * find_axis_device(void);

void delete_axis_pci_device(struct axis_pci_device_entry * device);

int pci_probe(struct pci_dev *dev,const struct pci_device_id *id);

void create_proc_id_entries(struct axis_pci_device_entry* device);
void delete_proc_id_entries(struct axis_pci_device_entry* device);


#endif //AXIS_PCI_H

---