1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Patch transfer callback for Emu10k1 4 * 5 * Copyright (C) 2000 Takashi iwai <tiwai@suse.de> 6 */ 7 /* 8 * All the code for loading in a patch. There is very little that is 9 * chip specific here. Just the actual writing to the board. 10 */ 11 12 #include "emu10k1_synth_local.h" 13 14 /* 15 */ 16 #define BLANK_LOOP_START 4 17 #define BLANK_LOOP_END 8 18 #define BLANK_LOOP_SIZE 12 19 #define BLANK_HEAD_SIZE 3 20 21 /* 22 * allocate a sample block and copy data from userspace 23 */ 24 int 25 snd_emu10k1_sample_new(struct snd_emux *rec, struct snd_sf_sample *sp, 26 struct snd_util_memhdr *hdr, 27 const void __user *data, long count) 28 { 29 u8 fill; 30 u32 xor; 31 int shift; 32 int offset; 33 int truesize, size, blocksize; 34 int loop_start, loop_end, loop_size, data_end, unroll; 35 struct snd_emu10k1 *emu; 36 37 emu = rec->hw; 38 if (snd_BUG_ON(!sp || !hdr)) 39 return -EINVAL; 40 41 if (sp->v.mode_flags & (SNDRV_SFNT_SAMPLE_BIDIR_LOOP | SNDRV_SFNT_SAMPLE_REVERSE_LOOP)) { 42 /* should instead return -ENOTSUPP; but compatibility */ 43 printk(KERN_WARNING "Emu10k1 wavetable patch %d with unsupported loop feature\n", 44 sp->v.sample); 45 } 46 47 if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_8BITS) { 48 shift = 0; 49 fill = 0x80; 50 xor = (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_UNSIGNED) ? 0 : 0x80808080; 51 } else { 52 shift = 1; 53 fill = 0; 54 xor = (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_UNSIGNED) ? 0x80008000 : 0; 55 } 56 57 /* compute true data size to be loaded */ 58 truesize = sp->v.size + BLANK_HEAD_SIZE; 59 if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_NO_BLANK) { 60 truesize += BLANK_LOOP_SIZE; 61 /* if no blank loop is attached in the sample, add it */ 62 if (sp->v.mode_flags & SNDRV_SFNT_SAMPLE_SINGLESHOT) { 63 sp->v.loopstart = sp->v.end + BLANK_LOOP_START; 64 sp->v.loopend = sp->v.end + BLANK_LOOP_END; 65 } 66 } 67 68 loop_start = sp->v.loopstart; 69 loop_end = sp->v.loopend; 70 loop_size = loop_end - loop_start; 71 if (!loop_size) 72 return -EINVAL; 73 data_end = sp->v.end; 74 75 /* recalculate offset */ 76 sp->v.start += BLANK_HEAD_SIZE; 77 sp->v.end += BLANK_HEAD_SIZE; 78 sp->v.loopstart += BLANK_HEAD_SIZE; 79 sp->v.loopend += BLANK_HEAD_SIZE; 80 81 // Automatic pre-filling of the cache does not work in the presence 82 // of loops (*), and we don't want to fill it manually, as that is 83 // fiddly and slow. So we unroll the loop until the loop end is 84 // beyond the cache size. 85 // (*) Strictly speaking, a single iteration is supported (that's 86 // how it works when the playback engine runs), but handling this 87 // special case is not worth it. 88 unroll = 0; 89 while (sp->v.loopend < 64) { 90 truesize += loop_size; 91 sp->v.loopstart += loop_size; 92 sp->v.loopend += loop_size; 93 sp->v.end += loop_size; 94 unroll++; 95 } 96 97 /* try to allocate a memory block */ 98 blocksize = truesize << shift; 99 sp->block = snd_emu10k1_synth_alloc(emu, blocksize); 100 if (sp->block == NULL) { 101 dev_dbg(emu->card->dev, 102 "synth malloc failed (size=%d)\n", blocksize); 103 /* not ENOMEM (for compatibility with OSS) */ 104 return -ENOSPC; 105 } 106 /* set the total size */ 107 sp->v.truesize = blocksize; 108 109 /* write blank samples at head */ 110 offset = 0; 111 size = BLANK_HEAD_SIZE << shift; 112 snd_emu10k1_synth_memset(emu, sp->block, offset, size, fill); 113 offset += size; 114 115 /* copy provided samples */ 116 if (unroll && loop_end <= data_end) { 117 size = loop_end << shift; 118 if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size, xor)) 119 goto faulty; 120 offset += size; 121 122 data += loop_start << shift; 123 while (--unroll > 0) { 124 size = loop_size << shift; 125 if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size, xor)) 126 goto faulty; 127 offset += size; 128 } 129 130 size = (data_end - loop_start) << shift; 131 } else { 132 size = data_end << shift; 133 } 134 if (snd_emu10k1_synth_copy_from_user(emu, sp->block, offset, data, size, xor)) 135 goto faulty; 136 offset += size; 137 138 /* clear rest of samples (if any) */ 139 if (offset < blocksize) 140 snd_emu10k1_synth_memset(emu, sp->block, offset, blocksize - offset, fill); 141 142 return 0; 143 144 faulty: 145 snd_emu10k1_synth_free(emu, sp->block); 146 sp->block = NULL; 147 return -EFAULT; 148 } 149 150 /* 151 * free a sample block 152 */ 153 int 154 snd_emu10k1_sample_free(struct snd_emux *rec, struct snd_sf_sample *sp, 155 struct snd_util_memhdr *hdr) 156 { 157 struct snd_emu10k1 *emu; 158 159 emu = rec->hw; 160 if (snd_BUG_ON(!sp || !hdr)) 161 return -EINVAL; 162 163 if (sp->block) { 164 snd_emu10k1_synth_free(emu, sp->block); 165 sp->block = NULL; 166 } 167 return 0; 168 } 169 170