Revert "Remove support for xpp drivers."
[dahdi/linux.git] / drivers / dahdi / xpp / xbus-core.h
1 /*
2  * Written by Oron Peled <oron@actcom.co.il>
3  * Copyright (C) 2004-2006, Xorcom
4  *
5  * All rights reserved.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  *
21  */
22 #ifndef XBUS_CORE_H
23 #define XBUS_CORE_H
24
25 #include <linux/wait.h>
26 #include <linux/interrupt.h>    /* for tasklets */
27 #include <linux/kref.h>
28 #include "xpd.h"
29 #include "xframe_queue.h"
30 #include "xbus-pcm.h"
31
32 #define MAX_BUSES       128
33 #define XFRAME_DATASIZE 512
34 #define MAX_ENV_STR     40
35
36 /* forward declarations */
37 struct xbus_workqueue;
38
39 #ifdef  __KERNEL__
40
41 struct xbus_ops {
42         int (*xframe_send_pcm) (xbus_t *xbus, xframe_t *xframe);
43         int (*xframe_send_cmd) (xbus_t *xbus, xframe_t *xframe);
44         xframe_t *(*alloc_xframe) (xbus_t *xbus, gfp_t gfp_flags);
45         void (*free_xframe) (xbus_t *xbus, xframe_t *xframe);
46 };
47
48 /*
49  * XBUS statistics counters
50  */
51 enum {
52         XBUS_N_UNITS,
53         XBUS_N_TX_XFRAME_PCM,
54         XBUS_N_RX_XFRAME_PCM,
55         XBUS_N_TX_PACK_PCM,
56         XBUS_N_RX_PACK_PCM,
57         XBUS_N_TX_BYTES,
58         XBUS_N_RX_BYTES,
59         XBUS_N_TX_PCM_FRAG,
60         XBUS_N_RX_CMD,
61         XBUS_N_TX_CMD,
62 };
63
64 #define XBUS_COUNTER(xbus, counter)     ((xbus)->counters[XBUS_N_ ## counter])
65
66 #define C_(x)   [ XBUS_N_ ## x ] = { #x }
67
68 /* yucky, make an instance so we can size it... */
69 static struct xbus_counters {
70         char *name;
71 } xbus_counters[] = {
72 C_(UNITS), C_(TX_XFRAME_PCM), C_(RX_XFRAME_PCM), C_(TX_PACK_PCM),
73             C_(RX_PACK_PCM), C_(TX_BYTES), C_(RX_BYTES),
74             C_(TX_PCM_FRAG), C_(RX_CMD), C_(TX_CMD),};
75
76 #undef C_
77
78 #define XBUS_COUNTER_MAX        ARRAY_SIZE(xbus_counters)
79
80 enum xbus_state {
81         XBUS_STATE_START,
82         XBUS_STATE_IDLE,
83         XBUS_STATE_SENT_REQUEST,
84         XBUS_STATE_RECVD_DESC,
85         XBUS_STATE_READY,
86         XBUS_STATE_DEACTIVATING,
87         XBUS_STATE_DEACTIVATED,
88         XBUS_STATE_FAIL,
89 };
90
91 const char *xbus_statename(enum xbus_state st);
92
93 struct xbus_transport {
94         struct xbus_ops *ops;
95         void *priv;
96         struct device *transport_device;
97         ushort max_send_size;
98         enum xbus_state xbus_state;
99         unsigned long transport_flags;
100         spinlock_t state_lock;
101         atomic_t transport_refcount;
102         wait_queue_head_t transport_unused;
103         spinlock_t lock;
104         char model_string[MAX_ENV_STR];
105 };
106
107 #define MAX_SEND_SIZE(xbus)     ((xbus)->transport.max_send_size)
108 #define XBUS_STATE(xbus)        ((xbus)->transport.xbus_state)
109 #define XBUS_IS(xbus, st)       (XBUS_STATE(xbus) == XBUS_STATE_ ## st)
110 #define TRANSPORT_EXIST(xbus)   ((xbus)->transport.ops != NULL)
111
112 #define XBUS_FLAG_CONNECTED     0
113 #define XBUS_FLAGS(xbus, flg) \
114         test_bit(XBUS_FLAG_ ## flg, &((xbus)->transport.transport_flags))
115
116 struct xbus_ops *transportops_get(xbus_t *xbus);
117 void transportops_put(xbus_t *xbus);
118
119 /*
120  * Encapsulate all poll related data of a single xbus.
121  */
122 struct xbus_workqueue {
123         struct workqueue_struct *wq;
124         struct work_struct xpds_init_work;
125         bool xpds_init_done;
126         struct list_head card_list;
127         int num_units;
128         int num_units_initialized;
129         wait_queue_head_t wait_for_xpd_initialization;
130         spinlock_t worker_lock;
131         struct semaphore running_initialization;
132 };
133
134 /*
135  * Allocate/Free an xframe from pools of empty xframes.
136  * Calls to {get, put}_xframe are wrapped in
137  * the macros bellow, so we take/return it
138  * to the correct pool.
139  */
140 xframe_t *get_xframe(struct xframe_queue *q);
141 void put_xframe(struct xframe_queue *q, xframe_t *xframe);
142
143 #define ALLOC_SEND_XFRAME(xbus) \
144                 get_xframe(&(xbus)->send_pool)
145 #define ALLOC_RECV_XFRAME(xbus) \
146                 get_xframe(&(xbus)->receive_pool)
147 #define FREE_SEND_XFRAME(xbus, xframe) \
148                 put_xframe(&(xbus)->send_pool, (xframe))
149 #define FREE_RECV_XFRAME(xbus, xframe) \
150                 put_xframe(&(xbus)->receive_pool, (xframe))
151
152 xbus_t *xbus_num(uint num);
153 xbus_t *get_xbus(const char *msg, uint num);
154 void put_xbus(const char *msg, xbus_t *xbus);
155 int refcount_xbus(xbus_t *xbus);
156
157 /*
158  * Echo canceller related data
159  */
160 #define ECHO_TIMESLOTS  128
161
162 struct echoops {
163         int (*ec_set) (xpd_t *xpd, int pos, bool on);
164         int (*ec_get) (xpd_t *xpd, int pos);
165         int (*ec_update) (xbus_t *xbus);
166         void (*ec_dump) (xbus_t *xbus);
167 };
168
169 struct xbus_echo_state {
170         const struct echoops *echoops;
171         __u8 timeslots[ECHO_TIMESLOTS];
172         int xpd_idx;
173         struct device_attribute *da[MAX_XPDS];
174 };
175 #define ECHOOPS(xbus)                   ((xbus)->echo_state.echoops)
176 #define EC_METHOD(name, xbus)           (ECHOOPS(xbus)->name)
177 #define CALL_EC_METHOD(name, xbus, ...) (EC_METHOD(name, (xbus))(__VA_ARGS__))
178
179 /*
180  * An xbus is a transport layer for Xorcom Protocol commands
181  */
182 struct xbus {
183         char busname[XBUS_NAMELEN];     /* set by xbus_new() */
184
185         /* low-level bus drivers set these 2 fields */
186         char connector[XBUS_DESCLEN];
187         char label[LABEL_SIZE];
188         __u8 revision;          /* Protocol revision */
189         struct xbus_transport transport;
190         struct dahdi_device *ddev;
191
192         int num;
193         struct xpd *xpds[MAX_XPDS];
194         struct xbus_echo_state echo_state;
195
196         int command_tick_counter;
197         int usec_nosend;        /* Firmware flow control */
198         struct xframe_queue command_queue;
199         wait_queue_head_t command_queue_empty;
200
201         struct xframe_queue send_pool;  /* empty xframes for send */
202         struct xframe_queue receive_pool;       /* empty xframes for receive */
203
204         /* tasklet processing */
205         struct xframe_queue receive_queue;
206         struct tasklet_struct receive_tasklet;
207         int cpu_rcv_intr[NR_CPUS];
208         int cpu_rcv_tasklet[NR_CPUS];
209
210         struct quirks {
211                 unsigned int has_fxo:1;
212                 unsigned int has_digital_span:1;
213         } quirks;
214         bool self_ticking;
215         enum sync_mode sync_mode;
216         /* Managed by low-level drivers: */
217         enum sync_mode sync_mode_default;
218         struct timer_list command_timer;
219         unsigned int xbus_frag_count;
220         struct xframe_queue pcm_tospan;
221
222         struct xpp_ticker ticker;       /* for tick rate */
223         struct xpp_drift drift; /* for tick offset */
224
225         atomic_t pcm_rx_counter;
226         unsigned int global_counter;
227
228         /* Device-Model */
229         struct device astribank;
230 #define dev_to_xbus(dev)        container_of(dev, struct xbus, astribank)
231         struct kref kref;
232 #define kref_to_xbus(k) container_of(k, struct xbus, kref)
233
234         spinlock_t lock;
235
236         /* PCM metrics */
237         struct timeval last_tx_sync;
238         struct timeval last_rx_sync;
239         unsigned long max_tx_sync;
240         unsigned long min_tx_sync;
241         unsigned long max_rx_sync;
242         unsigned long min_rx_sync;
243         unsigned long max_rx_process;   /* packet processing time (usec) */
244 #ifdef  SAMPLE_TICKS
245 #define SAMPLE_SIZE     1000
246         int sample_ticks[SAMPLE_SIZE];
247         bool sample_running;
248         int sample_pos;
249 #endif
250
251         struct xbus_workqueue worker;
252
253         /*
254          * Sync adjustment
255          */
256         int sync_adjustment;
257         int sync_adjustment_offset;
258         long pll_updated_at;
259
260         atomic_t num_xpds;
261
262 #ifdef CONFIG_PROC_FS
263         struct proc_dir_entry *proc_xbus_dir;
264         struct proc_dir_entry *proc_xbus_summary;
265 #ifdef  PROTOCOL_DEBUG
266         struct proc_dir_entry *proc_xbus_command;
267 #endif
268 #endif
269
270         /* statistics */
271         int counters[XBUS_COUNTER_MAX];
272 };
273 #endif
274
275 #define XFRAME_MAGIC    123456L
276
277 struct xframe {
278         unsigned long xframe_magic;
279         struct list_head frame_list;
280         atomic_t frame_len;
281         xbus_t *xbus;
282         struct timeval tv_created;
283         struct timeval tv_queued;
284         struct timeval tv_submitted;
285         struct timeval tv_received;
286         /* filled by transport layer */
287         size_t frame_maxlen;
288         __u8 *packets;          /* max XFRAME_DATASIZE */
289         __u8 *first_free;
290         int usec_towait;        /* prevent overflowing AB */
291         void *priv;
292 };
293
294 void xframe_init(xbus_t *xbus, xframe_t *xframe, void *buf, size_t maxsize,
295                  void *priv);
296
297 #define XFRAME_LEN(frame)       atomic_read(&(frame)->frame_len)
298
299 int xbus_core_init(void);       /* Initializer */
300 void xbus_core_shutdown(void);  /* Terminator */
301
302 /* Frame handling */
303 void dump_xframe(const char msg[], const xbus_t *xbus, const xframe_t *xframe,
304                  int debug);
305 int send_cmd_frame(xbus_t *xbus, xframe_t *xframe);
306
307 /*
308  * Return pointer to next packet slot in the frame
309  * or NULL if the frame is full.
310  */
311 xpacket_t *xframe_next_packet(xframe_t *xframe, int len);
312
313 /* XBUS handling */
314
315 /*
316  * Map: unit+subunit <--> index in xbus->xpds[]
317  */
318 #define XPD_IDX(unit, subunit)  ((unit) * MAX_SUBUNIT + (subunit))
319 #define XBUS_UNIT(idx)          ((idx) / MAX_SUBUNIT)
320 #define XBUS_SUBUNIT(idx)       ((idx) % MAX_SUBUNIT)
321
322 xpd_t *xpd_of(const xbus_t *xbus, int xpd_num);
323 xpd_t *xpd_byaddr(const xbus_t *xbus, uint unit, uint subunit);
324 int xbus_check_unique(xbus_t *xbus);
325 bool xbus_setstate(xbus_t *xbus, enum xbus_state newstate);
326 bool xbus_setflags(xbus_t *xbus, int flagbit, bool on);
327 xbus_t *xbus_new(struct xbus_ops *ops, ushort max_send_size,
328                  struct device *transport_device, void *priv);
329 void xbus_free(xbus_t *xbus);
330 int xbus_connect(xbus_t *xbus);
331 int xbus_activate(xbus_t *xbus);
332 void xbus_deactivate(xbus_t *xbus);
333 void xbus_disconnect(xbus_t *xbus);
334 void xbus_receive_xframe(xbus_t *xbus, xframe_t *xframe);
335 int xbus_process_worker(xbus_t *xbus);
336 int waitfor_xpds(xbus_t *xbus, char *buf);
337
338 int xbus_xpd_bind(xbus_t *xbus, xpd_t *xpd, int unit, int subunit);
339 int xbus_xpd_unbind(xbus_t *xbus, xpd_t *xpd);
340
341 int subunits_of_xpd(const struct unit_descriptor* unit_descriptor,
342                 const xproto_table_t *proto_table);
343 /* sysfs */
344 int xpd_device_register(xbus_t *xbus, xpd_t *xpd);
345 void xpd_device_unregister(xpd_t *xpd);
346 int echocancel_xpd(xpd_t *xpd, int on);
347
348 int xbus_is_registered(xbus_t *xbus);
349 int xbus_register_dahdi_device(xbus_t *xbus);
350 void xbus_unregister_dahdi_device(xbus_t *xbus);
351
352 int xpp_driver_init(void);
353 void xpp_driver_exit(void);
354 int xbus_sysfs_transport_create(xbus_t *xbus);
355 void xbus_sysfs_transport_remove(xbus_t *xbus);
356 int xbus_sysfs_create(xbus_t *xbus);
357 void xbus_sysfs_remove(xbus_t *xbus);
358
359 void astribank_uevent_send(xbus_t *xbus, enum kobject_action act);
360
361 #endif /* XBUS_CORE_H */