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