drivers/ieee1394/highlevel.h

   1 #ifndef IEEE1394_HIGHLEVEL_H
   2 #define IEEE1394_HIGHLEVEL_H
   3
   4 /* internal to ieee1394 core */
   5 struct hpsb_address_serve {
   6         struct list_head host_list;     /* per host list */
   7         struct list_head hl_list;       /* hpsb_highlevel list */
   8         struct hpsb_address_ops *op;
   9         struct hpsb_host *host;
  10         u64 start;      /* first address handled, quadlet aligned */
  11         u64 end;        /* first address behind, quadlet aligned */
  12 };
  13
  14 /* Only the following structures are of interest to actual highlevel drivers. */
  15
  16 struct hpsb_highlevel {
  17         struct module *owner;
  18         const char *name;
  19
  20         /* Any of the following pointers can legally be NULL, except for
  21          * iso_receive which can only be NULL when you don't request
  22          * channels. */
  23
  24         /* New host initialized.  Will also be called during
  25          * hpsb_register_highlevel for all hosts already installed. */
  26         void (*add_host)(struct hpsb_host *host);
  27
  28         /* Host about to be removed.  Will also be called during
  29          * hpsb_unregister_highlevel once for each host. */
  30         void (*remove_host)(struct hpsb_host *host);
  31
  32         /* Host experienced bus reset with possible configuration changes.
  33          * Note that this one may occur during interrupt/bottom half handling.
  34          * You can not expect to be able to do stock hpsb_reads. */
  35         void (*host_reset)(struct hpsb_host *host);
  36
  37         /* An isochronous packet was received.  Channel contains the channel
  38          * number for your convenience, it is also contained in the included
  39          * packet header (first quadlet, CRCs are missing).  You may get called
  40          * for channel/host combinations you did not request. */
  41         void (*iso_receive)(struct hpsb_host *host, int channel,
  42                             quadlet_t *data, size_t length);
  43
  44         /* A write request was received on either the FCP_COMMAND (direction =
  45          * 0) or the FCP_RESPONSE (direction = 1) register.  The cts arg
  46          * contains the cts field (first byte of data). */
  47         void (*fcp_request)(struct hpsb_host *host, int nodeid, int direction,
  48                             int cts, u8 *data, size_t length);
  49
  50         /* These are initialized by the subsystem when the
  51          * hpsb_higlevel is registered. */
  52         struct list_head hl_list;
  53         struct list_head irq_list;
  54         struct list_head addr_list;
  55
  56         struct list_head host_info_list;
  57         rwlock_t host_info_lock;
  58 };
  59
  60 struct hpsb_address_ops {
  61         /*
  62          * Null function pointers will make the respective operation complete
  63          * with RCODE_TYPE_ERROR.  Makes for easy to implement read-only
  64          * registers (just leave everything but read NULL).
  65          *
  66          * All functions shall return appropriate IEEE 1394 rcodes.
  67          */
  68
  69         /* These functions have to implement block reads for themselves.
  70          *
  71          * These functions either return a response code or a negative number.
  72          * In the first case a response will be generated.  In the latter case,
  73          * no response will be sent and the driver which handled the request
  74          * will send the response itself. */
  75         int (*read)(struct hpsb_host *host, int nodeid, quadlet_t *buffer,
  76                     u64 addr, size_t length, u16 flags);
  77         int (*write)(struct hpsb_host *host, int nodeid, int destid,
  78                      quadlet_t *data, u64 addr, size_t length, u16 flags);
  79
  80         /* Lock transactions: write results of ext_tcode operation into
  81          * *store. */
  82         int (*lock)(struct hpsb_host *host, int nodeid, quadlet_t *store,
  83                     u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode,
  84                     u16 flags);
  85         int (*lock64)(struct hpsb_host *host, int nodeid, octlet_t *store,
  86                       u64 addr, octlet_t data, octlet_t arg, int ext_tcode,
  87                       u16 flags);
  88 };
  89
  90 void highlevel_add_host(struct hpsb_host *host);
  91 void highlevel_remove_host(struct hpsb_host *host);
  92 void highlevel_host_reset(struct hpsb_host *host);
  93
  94 /*
  95  * These functions are called to handle transactions. They are called when a
  96  * packet arrives.  The flags argument contains the second word of the first
  97  * header quadlet of the incoming packet (containing transaction label, retry
  98  * code, transaction code and priority).  These functions either return a
  99  * response code or a negative number.  In the first case a response will be
 100  * generated.  In the latter case, no response will be sent and the driver which
 101  * handled the request will send the response itself.
 102  */
 103 int highlevel_read(struct hpsb_host *host, int nodeid, void *data, u64 addr,
 104                    unsigned int length, u16 flags);
 105 int highlevel_write(struct hpsb_host *host, int nodeid, int destid, void *data,
 106                     u64 addr, unsigned int length, u16 flags);
 107 int highlevel_lock(struct hpsb_host *host, int nodeid, quadlet_t *store,
 108                    u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode,
 109                    u16 flags);
 110 int highlevel_lock64(struct hpsb_host *host, int nodeid, octlet_t *store,
 111                      u64 addr, octlet_t data, octlet_t arg, int ext_tcode,
 112                      u16 flags);
 113
 114 void highlevel_iso_receive(struct hpsb_host *host, void *data, size_t length);
 115 void highlevel_fcp_request(struct hpsb_host *host, int nodeid, int direction,
 116                            void *data, size_t length);
 117
 118 /*
 119  * Register highlevel driver.  The name pointer has to stay valid at all times
 120  * because the string is not copied.
 121  */
 122 void hpsb_register_highlevel(struct hpsb_highlevel *hl);
 123 void hpsb_unregister_highlevel(struct hpsb_highlevel *hl);
 124
 125 /*
 126  * Register handlers for host address spaces.  Start and end are 48 bit pointers
 127  * and have to be quadlet aligned.  Argument "end" points to the first address
 128  * behind the handled addresses.  This function can be called multiple times for
 129  * a single hpsb_highlevel to implement sparse register sets.  The requested
 130  * region must not overlap any previously allocated region, otherwise
 131  * registering will fail.
 132  *
 133  * It returns true for successful allocation.  Address spaces can be
 134  * unregistered with hpsb_unregister_addrspace.  All remaining address spaces
 135  * are automatically deallocated together with the hpsb_highlevel.
 136  */
 137 u64 hpsb_allocate_and_register_addrspace(struct hpsb_highlevel *hl,
 138                                          struct hpsb_host *host,
 139                                          struct hpsb_address_ops *ops,
 140                                          u64 size, u64 alignment,
 141                                          u64 start, u64 end);
 142 int hpsb_register_addrspace(struct hpsb_highlevel *hl, struct hpsb_host *host,
 143                             struct hpsb_address_ops *ops, u64 start, u64 end);
 144 int hpsb_unregister_addrspace(struct hpsb_highlevel *hl, struct hpsb_host *host,
 145                               u64 start);
 146
 147 /*
 148  * Enable or disable receving a certain isochronous channel through the
 149  * iso_receive op.
 150  */
 151 int hpsb_listen_channel(struct hpsb_highlevel *hl, struct hpsb_host *host,
 152                          unsigned int channel);
 153 void hpsb_unlisten_channel(struct hpsb_highlevel *hl, struct hpsb_host *host,
 154                            unsigned int channel);
 155
 156 /* Retrieve a hostinfo pointer bound to this driver/host */
 157 void *hpsb_get_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host);
 158
 159 /* Allocate a hostinfo pointer of data_size bound to this driver/host */
 160 void *hpsb_create_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host,
 161                            size_t data_size);
 162
 163 /* Free and remove the hostinfo pointer bound to this driver/host */
 164 void hpsb_destroy_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host);
 165
 166 /* Set an alternate lookup key for the hostinfo bound to this driver/host */
 167 void hpsb_set_hostinfo_key(struct hpsb_highlevel *hl, struct hpsb_host *host,
 168                            unsigned long key);
 169
 170 /* Retrieve the alternate lookup key for the hostinfo bound to this
 171  * driver/host */
 172 unsigned long hpsb_get_hostinfo_key(struct hpsb_highlevel *hl,
 173                                     struct hpsb_host *host);
 174
 175 /* Retrieve a hostinfo pointer bound to this driver using its alternate key */
 176 void *hpsb_get_hostinfo_bykey(struct hpsb_highlevel *hl, unsigned long key);
 177
 178 /* Set the hostinfo pointer to something useful. Usually follows a call to
 179  * hpsb_create_hostinfo, where the size is 0. */
 180 int hpsb_set_hostinfo(struct hpsb_highlevel *hl, struct hpsb_host *host,
 181                       void *data);
 182
 183 /* Retrieve hpsb_host using a highlevel handle and a key */
 184 struct hpsb_host *hpsb_get_host_bykey(struct hpsb_highlevel *hl,
 185                                       unsigned long key);
 186
 187 #endif /* IEEE1394_HIGHLEVEL_H */