1/*
  2 * dice.h - a part of driver for Dice based devices
  3 *
  4 * Copyright (c) Clemens Ladisch
  5 * Copyright (c) 2014 Takashi Sakamoto
  6 *
  7 * Licensed under the terms of the GNU General Public License, version 2.
  8 */
  9
 10#ifndef SOUND_DICE_H_INCLUDED
 11#define SOUND_DICE_H_INCLUDED
 12
 13#include <linux/compat.h>
 14#include <linux/completion.h>
 15#include <linux/delay.h>
 16#include <linux/device.h>
 17#include <linux/firewire.h>
 18#include <linux/firewire-constants.h>
 19#include <linux/jiffies.h>
 20#include <linux/module.h>
 21#include <linux/mod_devicetable.h>
 22#include <linux/mutex.h>
 23#include <linux/slab.h>
 24#include <linux/spinlock.h>
 25#include <linux/wait.h>
 26
 27#include <sound/control.h>
 28#include <sound/core.h>
 29#include <sound/firewire.h>
 30#include <sound/hwdep.h>
 31#include <sound/info.h>
 32#include <sound/initval.h>
 33#include <sound/pcm.h>
 34#include <sound/pcm_params.h>
 35#include <sound/rawmidi.h>
 36
 37#include "../amdtp-am824.h"
 38#include "../iso-resources.h"
 39#include "../lib.h"
 40#include "dice-interface.h"
 41
 42/*
 43 * This module support maximum 2 pairs of tx/rx isochronous streams for
 44 * our convinience.
 45 *
 46 * In documents for ASICs called with a name of 'DICE':
 47 *  - ASIC for DICE II:
 48 *   - Maximum 2 tx and 4 rx are supported.
 49 *   - A packet supports maximum 16 data channels.
 50 *  - TCD2210/2210-E (so-called 'Dice Mini'):
 51 *   - Maximum 2 tx and 2 rx are supported.
 52 *   - A packet supports maximum 16 data channels.
 53 *  - TCD2220/2220-E (so-called 'Dice Jr.')
 54 *   - 2 tx and 2 rx are supported.
 55 *   - A packet supports maximum 16 data channels.
 56 *  - TCD3070-CH (so-called 'Dice III')
 57 *   - Maximum 2 tx and 2 rx are supported.
 58 *   - A packet supports maximum 32 data channels.
 59 *
 60 * For the above, MIDI conformant data channel is just on the first isochronous
 61 * stream.
 62 */
 63#define MAX_STREAMS	2
 64
 65struct snd_dice {
 66	struct snd_card *card;
 67	struct fw_unit *unit;
 68	spinlock_t lock;
 69	struct mutex mutex;
 70
 71	bool registered;
 72	struct delayed_work dwork;
 73
 74	/* Offsets for sub-addresses */
 75	unsigned int global_offset;
 76	unsigned int rx_offset;
 77	unsigned int tx_offset;
 78	unsigned int sync_offset;
 79	unsigned int rsrv_offset;
 80
 81	unsigned int clock_caps;
 82
 83	struct fw_address_handler notification_handler;
 84	int owner_generation;
 85	u32 notification_bits;
 86
 87	/* For uapi */
 88	int dev_lock_count; /* > 0 driver, < 0 userspace */
 89	bool dev_lock_changed;
 90	wait_queue_head_t hwdep_wait;
 91
 92	/* For streaming */
 93	struct fw_iso_resources tx_resources[MAX_STREAMS];
 94	struct fw_iso_resources rx_resources[MAX_STREAMS];
 95	struct amdtp_stream tx_stream[MAX_STREAMS];
 96	struct amdtp_stream rx_stream[MAX_STREAMS];
 97	bool global_enabled;
 98	struct completion clock_accepted;
 99	unsigned int substreams_counter;
100
101	bool force_two_pcms;
102};
103
104enum snd_dice_addr_type {
105	SND_DICE_ADDR_TYPE_PRIVATE,
106	SND_DICE_ADDR_TYPE_GLOBAL,
107	SND_DICE_ADDR_TYPE_TX,
108	SND_DICE_ADDR_TYPE_RX,
109	SND_DICE_ADDR_TYPE_SYNC,
110	SND_DICE_ADDR_TYPE_RSRV,
111};
112
113int snd_dice_transaction_write(struct snd_dice *dice,
114			       enum snd_dice_addr_type type,
115			       unsigned int offset,
116			       void *buf, unsigned int len);
117int snd_dice_transaction_read(struct snd_dice *dice,
118			      enum snd_dice_addr_type type, unsigned int offset,
119			      void *buf, unsigned int len);
120
121static inline int snd_dice_transaction_write_global(struct snd_dice *dice,
122						    unsigned int offset,
123						    void *buf, unsigned int len)
124{
125	return snd_dice_transaction_write(dice,
126					  SND_DICE_ADDR_TYPE_GLOBAL, offset,
127					  buf, len);
128}
129static inline int snd_dice_transaction_read_global(struct snd_dice *dice,
130						   unsigned int offset,
131						   void *buf, unsigned int len)
132{
133	return snd_dice_transaction_read(dice,
134					 SND_DICE_ADDR_TYPE_GLOBAL, offset,
135					 buf, len);
136}
137static inline int snd_dice_transaction_write_tx(struct snd_dice *dice,
138						unsigned int offset,
139						void *buf, unsigned int len)
140{
141	return snd_dice_transaction_write(dice, SND_DICE_ADDR_TYPE_TX, offset,
142					  buf, len);
143}
144static inline int snd_dice_transaction_read_tx(struct snd_dice *dice,
145					       unsigned int offset,
146					       void *buf, unsigned int len)
147{
148	return snd_dice_transaction_read(dice, SND_DICE_ADDR_TYPE_TX, offset,
149					 buf, len);
150}
151static inline int snd_dice_transaction_write_rx(struct snd_dice *dice,
152						unsigned int offset,
153						void *buf, unsigned int len)
154{
155	return snd_dice_transaction_write(dice, SND_DICE_ADDR_TYPE_RX, offset,
156					  buf, len);
157}
158static inline int snd_dice_transaction_read_rx(struct snd_dice *dice,
159					       unsigned int offset,
160					       void *buf, unsigned int len)
161{
162	return snd_dice_transaction_read(dice, SND_DICE_ADDR_TYPE_RX, offset,
163					 buf, len);
164}
165static inline int snd_dice_transaction_write_sync(struct snd_dice *dice,
166						  unsigned int offset,
167						  void *buf, unsigned int len)
168{
169	return snd_dice_transaction_write(dice, SND_DICE_ADDR_TYPE_SYNC, offset,
170					  buf, len);
171}
172static inline int snd_dice_transaction_read_sync(struct snd_dice *dice,
173						 unsigned int offset,
174						 void *buf, unsigned int len)
175{
176	return snd_dice_transaction_read(dice, SND_DICE_ADDR_TYPE_SYNC, offset,
177					 buf, len);
178}
179
180int snd_dice_transaction_get_clock_source(struct snd_dice *dice,
181					  unsigned int *source);
182int snd_dice_transaction_get_rate(struct snd_dice *dice, unsigned int *rate);
183int snd_dice_transaction_set_enable(struct snd_dice *dice);
184void snd_dice_transaction_clear_enable(struct snd_dice *dice);
185int snd_dice_transaction_init(struct snd_dice *dice);
186int snd_dice_transaction_reinit(struct snd_dice *dice);
187void snd_dice_transaction_destroy(struct snd_dice *dice);
188
189#define SND_DICE_RATES_COUNT	7
190extern const unsigned int snd_dice_rates[SND_DICE_RATES_COUNT];
191
192int snd_dice_stream_start_duplex(struct snd_dice *dice, unsigned int rate);
193void snd_dice_stream_stop_duplex(struct snd_dice *dice);
194int snd_dice_stream_init_duplex(struct snd_dice *dice);
195void snd_dice_stream_destroy_duplex(struct snd_dice *dice);
196void snd_dice_stream_update_duplex(struct snd_dice *dice);
197
198int snd_dice_stream_lock_try(struct snd_dice *dice);
199void snd_dice_stream_lock_release(struct snd_dice *dice);
200
201int snd_dice_create_pcm(struct snd_dice *dice);
202
203int snd_dice_create_hwdep(struct snd_dice *dice);
204
205void snd_dice_create_proc(struct snd_dice *dice);
206
207int snd_dice_create_midi(struct snd_dice *dice);
208
209#endif