1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2000 Dmitry Dicky diwil@dataart.com
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #ifdef HAVE_KERNEL_OPTION_HEADERS
30 #include "opt_snd.h"
31 #endif
32
33 #include <dev/sound/pcm/sound.h>
34 #include <dev/sound/pcm/ac97.h>
35 #include <dev/pci/pcireg.h>
36 #include <dev/pci/pcivar.h>
37
38 SND_DECLARE_FILE("$FreeBSD: stable/12/sys/dev/sound/pci/fm801.c 326255 2017-11-27 14:52:40Z pfg $");
39
40 #define PCI_VENDOR_FORTEMEDIA 0x1319
41 #define PCI_DEVICE_FORTEMEDIA1 0x08011319 /* Audio controller */
42 #define PCI_DEVICE_FORTEMEDIA2 0x08021319 /* Joystick controller */
43
44 #define FM_PCM_VOLUME 0x00
45 #define FM_FM_VOLUME 0x02
46 #define FM_I2S_VOLUME 0x04
47 #define FM_RECORD_SOURCE 0x06
48
49 #define FM_PLAY_CTL 0x08
50 #define FM_PLAY_RATE_MASK 0x0f00
51 #define FM_PLAY_BUF1_LAST 0x0001
52 #define FM_PLAY_BUF2_LAST 0x0002
53 #define FM_PLAY_START 0x0020
54 #define FM_PLAY_PAUSE 0x0040
55 #define FM_PLAY_STOPNOW 0x0080
56 #define FM_PLAY_16BIT 0x4000
57 #define FM_PLAY_STEREO 0x8000
58
59 #define FM_PLAY_DMALEN 0x0a
60 #define FM_PLAY_DMABUF1 0x0c
61 #define FM_PLAY_DMABUF2 0x10
62
63
64 #define FM_REC_CTL 0x14
65 #define FM_REC_RATE_MASK 0x0f00
66 #define FM_REC_BUF1_LAST 0x0001
67 #define FM_REC_BUF2_LAST 0x0002
68 #define FM_REC_START 0x0020
69 #define FM_REC_PAUSE 0x0040
70 #define FM_REC_STOPNOW 0x0080
71 #define FM_REC_16BIT 0x4000
72 #define FM_REC_STEREO 0x8000
73
74
75 #define FM_REC_DMALEN 0x16
76 #define FM_REC_DMABUF1 0x18
77 #define FM_REC_DMABUF2 0x1c
78
79 #define FM_CODEC_CTL 0x22
80 #define FM_VOLUME 0x26
81 #define FM_VOLUME_MUTE 0x8000
82
83 #define FM_CODEC_CMD 0x2a
84 #define FM_CODEC_CMD_READ 0x0080
85 #define FM_CODEC_CMD_VALID 0x0100
86 #define FM_CODEC_CMD_BUSY 0x0200
87
88 #define FM_CODEC_DATA 0x2c
89
90 #define FM_IO_CTL 0x52
91 #define FM_CARD_CTL 0x54
92
93 #define FM_INTMASK 0x56
94 #define FM_INTMASK_PLAY 0x0001
95 #define FM_INTMASK_REC 0x0002
96 #define FM_INTMASK_VOL 0x0040
97 #define FM_INTMASK_MPU 0x0080
98
99 #define FM_INTSTATUS 0x5a
100 #define FM_INTSTATUS_PLAY 0x0100
101 #define FM_INTSTATUS_REC 0x0200
102 #define FM_INTSTATUS_VOL 0x4000
103 #define FM_INTSTATUS_MPU 0x8000
104
105 #define FM801_DEFAULT_BUFSZ 4096 /* Other values do not work!!! */
106
107 /* debug purposes */
108 #define DPRINT if(0) printf
109
110 /*
111 static int fm801ch_setup(struct pcm_channel *c);
112 */
113
114 static u_int32_t fmts[] = {
115 SND_FORMAT(AFMT_U8, 1, 0),
116 SND_FORMAT(AFMT_U8, 2, 0),
117 SND_FORMAT(AFMT_S16_LE, 1, 0),
118 SND_FORMAT(AFMT_S16_LE, 2, 0),
119 0
120 };
121
122 static struct pcmchan_caps fm801ch_caps = {
123 5500, 48000,
124 fmts, 0
125 };
126
127 struct fm801_info;
128
129 struct fm801_chinfo {
130 struct fm801_info *parent;
131 struct pcm_channel *channel;
132 struct snd_dbuf *buffer;
133 u_int32_t spd, dir, fmt; /* speed, direction, format */
134 u_int32_t shift;
135 };
136
137 struct fm801_info {
138 int type;
139 bus_space_tag_t st;
140 bus_space_handle_t sh;
141 bus_dma_tag_t parent_dmat;
142
143 device_t dev;
144 int num;
145 u_int32_t unit;
146
147 struct resource *reg, *irq;
148 int regtype, regid, irqid;
149 void *ih;
150
151 u_int32_t play_flip,
152 play_nextblk,
153 play_start,
154 play_blksize,
155 play_fmt,
156 play_shift,
157 play_size;
158
159 u_int32_t rec_flip,
160 rec_nextblk,
161 rec_start,
162 rec_blksize,
163 rec_fmt,
164 rec_shift,
165 rec_size;
166
167 unsigned int bufsz;
168
169 struct fm801_chinfo pch, rch;
170
171 device_t radio;
172 };
173
174 /* Bus Read / Write routines */
175 static u_int32_t
fm801_rd(struct fm801_info * fm801,int regno,int size)176 fm801_rd(struct fm801_info *fm801, int regno, int size)
177 {
178 switch(size) {
179 case 1:
180 return (bus_space_read_1(fm801->st, fm801->sh, regno));
181 case 2:
182 return (bus_space_read_2(fm801->st, fm801->sh, regno));
183 case 4:
184 return (bus_space_read_4(fm801->st, fm801->sh, regno));
185 default:
186 return 0xffffffff;
187 }
188 }
189
190 static void
fm801_wr(struct fm801_info * fm801,int regno,u_int32_t data,int size)191 fm801_wr(struct fm801_info *fm801, int regno, u_int32_t data, int size)
192 {
193
194 switch(size) {
195 case 1:
196 bus_space_write_1(fm801->st, fm801->sh, regno, data);
197 break;
198 case 2:
199 bus_space_write_2(fm801->st, fm801->sh, regno, data);
200 break;
201 case 4:
202 bus_space_write_4(fm801->st, fm801->sh, regno, data);
203 break;
204 }
205 }
206
207 /* -------------------------------------------------------------------- */
208 /*
209 * ac97 codec routines
210 */
211 #define TIMO 50
212 static int
fm801_rdcd(kobj_t obj,void * devinfo,int regno)213 fm801_rdcd(kobj_t obj, void *devinfo, int regno)
214 {
215 struct fm801_info *fm801 = (struct fm801_info *)devinfo;
216 int i;
217
218 for (i = 0; i < TIMO && fm801_rd(fm801,FM_CODEC_CMD,2) & FM_CODEC_CMD_BUSY; i++) {
219 DELAY(10000);
220 DPRINT("fm801 rdcd: 1 - DELAY\n");
221 }
222 if (i >= TIMO) {
223 printf("fm801 rdcd: codec busy\n");
224 return 0;
225 }
226
227 fm801_wr(fm801,FM_CODEC_CMD, regno|FM_CODEC_CMD_READ,2);
228
229 for (i = 0; i < TIMO && !(fm801_rd(fm801,FM_CODEC_CMD,2) & FM_CODEC_CMD_VALID); i++)
230 {
231 DELAY(10000);
232 DPRINT("fm801 rdcd: 2 - DELAY\n");
233 }
234 if (i >= TIMO) {
235 printf("fm801 rdcd: write codec invalid\n");
236 return 0;
237 }
238
239 return fm801_rd(fm801,FM_CODEC_DATA,2);
240 }
241
242 static int
fm801_wrcd(kobj_t obj,void * devinfo,int regno,u_int32_t data)243 fm801_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data)
244 {
245 struct fm801_info *fm801 = (struct fm801_info *)devinfo;
246 int i;
247
248 DPRINT("fm801_wrcd reg 0x%x val 0x%x\n",regno, data);
249 /*
250 if(regno == AC97_REG_RECSEL) return;
251 */
252 /* Poll until codec is ready */
253 for (i = 0; i < TIMO && fm801_rd(fm801,FM_CODEC_CMD,2) & FM_CODEC_CMD_BUSY; i++) {
254 DELAY(10000);
255 DPRINT("fm801 rdcd: 1 - DELAY\n");
256 }
257 if (i >= TIMO) {
258 printf("fm801 wrcd: read codec busy\n");
259 return -1;
260 }
261
262 fm801_wr(fm801,FM_CODEC_DATA,data, 2);
263 fm801_wr(fm801,FM_CODEC_CMD, regno,2);
264
265 /* wait until codec is ready */
266 for (i = 0; i < TIMO && fm801_rd(fm801,FM_CODEC_CMD,2) & FM_CODEC_CMD_BUSY; i++) {
267 DELAY(10000);
268 DPRINT("fm801 wrcd: 2 - DELAY\n");
269 }
270 if (i >= TIMO) {
271 printf("fm801 wrcd: read codec busy\n");
272 return -1;
273 }
274 DPRINT("fm801 wrcd release reg 0x%x val 0x%x\n",regno, data);
275 return 0;
276 }
277
278 static kobj_method_t fm801_ac97_methods[] = {
279 KOBJMETHOD(ac97_read, fm801_rdcd),
280 KOBJMETHOD(ac97_write, fm801_wrcd),
281 DEVMETHOD_END
282 };
283 AC97_DECLARE(fm801_ac97);
284
285 /* -------------------------------------------------------------------- */
286
287 /*
288 * The interrupt handler
289 */
290 static void
fm801_intr(void * p)291 fm801_intr(void *p)
292 {
293 struct fm801_info *fm801 = (struct fm801_info *)p;
294 u_int32_t intsrc = fm801_rd(fm801, FM_INTSTATUS, 2);
295
296 DPRINT("\nfm801_intr intsrc 0x%x ", intsrc);
297
298 if(intsrc & FM_INTSTATUS_PLAY) {
299 fm801->play_flip++;
300 if(fm801->play_flip & 1) {
301 fm801_wr(fm801, FM_PLAY_DMABUF1, fm801->play_start,4);
302 } else
303 fm801_wr(fm801, FM_PLAY_DMABUF2, fm801->play_nextblk,4);
304 chn_intr(fm801->pch.channel);
305 }
306
307 if(intsrc & FM_INTSTATUS_REC) {
308 fm801->rec_flip++;
309 if(fm801->rec_flip & 1) {
310 fm801_wr(fm801, FM_REC_DMABUF1, fm801->rec_start,4);
311 } else
312 fm801_wr(fm801, FM_REC_DMABUF2, fm801->rec_nextblk,4);
313 chn_intr(fm801->rch.channel);
314 }
315
316 if ( intsrc & FM_INTSTATUS_MPU ) {
317 /* This is a TODOish thing... */
318 fm801_wr(fm801, FM_INTSTATUS, intsrc & FM_INTSTATUS_MPU,2);
319 }
320
321 if ( intsrc & FM_INTSTATUS_VOL ) {
322 /* This is a TODOish thing... */
323 fm801_wr(fm801, FM_INTSTATUS, intsrc & FM_INTSTATUS_VOL,2);
324 }
325
326 DPRINT("fm801_intr clear\n\n");
327 fm801_wr(fm801, FM_INTSTATUS, intsrc & (FM_INTSTATUS_PLAY | FM_INTSTATUS_REC), 2);
328 }
329
330 /* -------------------------------------------------------------------- */
331 /* channel interface */
332 static void *
fm801ch_init(kobj_t obj,void * devinfo,struct snd_dbuf * b,struct pcm_channel * c,int dir)333 fm801ch_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir)
334 {
335 struct fm801_info *fm801 = (struct fm801_info *)devinfo;
336 struct fm801_chinfo *ch = (dir == PCMDIR_PLAY)? &fm801->pch : &fm801->rch;
337
338 DPRINT("fm801ch_init, direction = %d\n", dir);
339 ch->parent = fm801;
340 ch->channel = c;
341 ch->buffer = b;
342 ch->dir = dir;
343 if (sndbuf_alloc(ch->buffer, fm801->parent_dmat, 0, fm801->bufsz) != 0)
344 return NULL;
345 return (void *)ch;
346 }
347
348 static int
fm801ch_setformat(kobj_t obj,void * data,u_int32_t format)349 fm801ch_setformat(kobj_t obj, void *data, u_int32_t format)
350 {
351 struct fm801_chinfo *ch = data;
352 struct fm801_info *fm801 = ch->parent;
353
354 DPRINT("fm801ch_setformat 0x%x : %s, %s, %s, %s\n", format,
355 (AFMT_CHANNEL(format) > 1)?"stereo":"mono",
356 (format & AFMT_16BIT) ? "16bit":"8bit",
357 (format & AFMT_SIGNED)? "signed":"unsigned",
358 (format & AFMT_BIGENDIAN)?"bigendiah":"littleendian" );
359
360 if(ch->dir == PCMDIR_PLAY) {
361 fm801->play_fmt =
362 (AFMT_CHANNEL(format) > 1)? FM_PLAY_STEREO : 0;
363 fm801->play_fmt |= (format & AFMT_16BIT) ? FM_PLAY_16BIT : 0;
364 return 0;
365 }
366
367 if(ch->dir == PCMDIR_REC ) {
368 fm801->rec_fmt = (AFMT_CHANNEL(format) > 1)? FM_REC_STEREO:0;
369 fm801->rec_fmt |= (format & AFMT_16BIT) ? FM_PLAY_16BIT : 0;
370 return 0;
371 }
372
373 return 0;
374 }
375
376 struct {
377 u_int32_t limit;
378 u_int32_t rate;
379 } fm801_rates[11] = {
380 { 6600, 5500 },
381 { 8750, 8000 },
382 { 10250, 9600 },
383 { 13200, 11025 },
384 { 17500, 16000 },
385 { 20500, 19200 },
386 { 26500, 22050 },
387 { 35000, 32000 },
388 { 41000, 38400 },
389 { 46000, 44100 },
390 { 48000, 48000 },
391 /* anything above -> 48000 */
392 };
393
394 static u_int32_t
fm801ch_setspeed(kobj_t obj,void * data,u_int32_t speed)395 fm801ch_setspeed(kobj_t obj, void *data, u_int32_t speed)
396 {
397 struct fm801_chinfo *ch = data;
398 struct fm801_info *fm801 = ch->parent;
399 int i;
400
401
402 for (i = 0; i < 10 && fm801_rates[i].limit <= speed; i++) ;
403
404 if(ch->dir == PCMDIR_PLAY) {
405 fm801->pch.spd = fm801_rates[i].rate;
406 fm801->play_shift = (i<<8);
407 fm801->play_shift &= FM_PLAY_RATE_MASK;
408 }
409
410 if(ch->dir == PCMDIR_REC ) {
411 fm801->rch.spd = fm801_rates[i].rate;
412 fm801->rec_shift = (i<<8);
413 fm801->rec_shift &= FM_REC_RATE_MASK;
414 }
415
416 ch->spd = fm801_rates[i].rate;
417
418 return fm801_rates[i].rate;
419 }
420
421 static u_int32_t
fm801ch_setblocksize(kobj_t obj,void * data,u_int32_t blocksize)422 fm801ch_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
423 {
424 struct fm801_chinfo *ch = data;
425 struct fm801_info *fm801 = ch->parent;
426
427 /*
428 * Don't mind for play_flip, set the blocksize to the
429 * desired values in any case - otherwise sound playback
430 * breaks here.
431 */
432 if(ch->dir == PCMDIR_PLAY)
433 fm801->play_blksize = blocksize;
434
435 if(ch->dir == PCMDIR_REC)
436 fm801->rec_blksize = blocksize;
437
438 DPRINT("fm801ch_setblocksize %d (dir %d)\n",blocksize, ch->dir);
439
440 return blocksize;
441 }
442
443 static int
fm801ch_trigger(kobj_t obj,void * data,int go)444 fm801ch_trigger(kobj_t obj, void *data, int go)
445 {
446 struct fm801_chinfo *ch = data;
447 struct fm801_info *fm801 = ch->parent;
448 u_int32_t baseaddr = sndbuf_getbufaddr(ch->buffer);
449 u_int32_t k1;
450
451 DPRINT("fm801ch_trigger go %d , ", go);
452
453 if (!PCMTRIG_COMMON(go))
454 return 0;
455
456 if (ch->dir == PCMDIR_PLAY) {
457 if (go == PCMTRIG_START) {
458
459 fm801->play_start = baseaddr;
460 fm801->play_nextblk = fm801->play_start + fm801->play_blksize;
461 fm801->play_flip = 0;
462 fm801_wr(fm801, FM_PLAY_DMALEN, fm801->play_blksize - 1, 2);
463 fm801_wr(fm801, FM_PLAY_DMABUF1,fm801->play_start,4);
464 fm801_wr(fm801, FM_PLAY_DMABUF2,fm801->play_nextblk,4);
465 fm801_wr(fm801, FM_PLAY_CTL,
466 FM_PLAY_START | FM_PLAY_STOPNOW | fm801->play_fmt | fm801->play_shift,
467 2 );
468 } else {
469 fm801->play_flip = 0;
470 k1 = fm801_rd(fm801, FM_PLAY_CTL,2);
471 fm801_wr(fm801, FM_PLAY_CTL,
472 (k1 & ~(FM_PLAY_STOPNOW | FM_PLAY_START)) |
473 FM_PLAY_BUF1_LAST | FM_PLAY_BUF2_LAST, 2 );
474 }
475 } else if(ch->dir == PCMDIR_REC) {
476 if (go == PCMTRIG_START) {
477 fm801->rec_start = baseaddr;
478 fm801->rec_nextblk = fm801->rec_start + fm801->rec_blksize;
479 fm801->rec_flip = 0;
480 fm801_wr(fm801, FM_REC_DMALEN, fm801->rec_blksize - 1, 2);
481 fm801_wr(fm801, FM_REC_DMABUF1,fm801->rec_start,4);
482 fm801_wr(fm801, FM_REC_DMABUF2,fm801->rec_nextblk,4);
483 fm801_wr(fm801, FM_REC_CTL,
484 FM_REC_START | FM_REC_STOPNOW | fm801->rec_fmt | fm801->rec_shift,
485 2 );
486 } else {
487 fm801->rec_flip = 0;
488 k1 = fm801_rd(fm801, FM_REC_CTL,2);
489 fm801_wr(fm801, FM_REC_CTL,
490 (k1 & ~(FM_REC_STOPNOW | FM_REC_START)) |
491 FM_REC_BUF1_LAST | FM_REC_BUF2_LAST, 2);
492 }
493 }
494
495 return 0;
496 }
497
498 /* Almost ALSA copy */
499 static u_int32_t
fm801ch_getptr(kobj_t obj,void * data)500 fm801ch_getptr(kobj_t obj, void *data)
501 {
502 struct fm801_chinfo *ch = data;
503 struct fm801_info *fm801 = ch->parent;
504 u_int32_t result = 0;
505
506 if (ch->dir == PCMDIR_PLAY) {
507 result = fm801_rd(fm801,
508 (fm801->play_flip&1) ?
509 FM_PLAY_DMABUF2:FM_PLAY_DMABUF1, 4) - fm801->play_start;
510 }
511
512 if (ch->dir == PCMDIR_REC) {
513 result = fm801_rd(fm801,
514 (fm801->rec_flip&1) ?
515 FM_REC_DMABUF2:FM_REC_DMABUF1, 4) - fm801->rec_start;
516 }
517
518 return result;
519 }
520
521 static struct pcmchan_caps *
fm801ch_getcaps(kobj_t obj,void * data)522 fm801ch_getcaps(kobj_t obj, void *data)
523 {
524 return &fm801ch_caps;
525 }
526
527 static kobj_method_t fm801ch_methods[] = {
528 KOBJMETHOD(channel_init, fm801ch_init),
529 KOBJMETHOD(channel_setformat, fm801ch_setformat),
530 KOBJMETHOD(channel_setspeed, fm801ch_setspeed),
531 KOBJMETHOD(channel_setblocksize, fm801ch_setblocksize),
532 KOBJMETHOD(channel_trigger, fm801ch_trigger),
533 KOBJMETHOD(channel_getptr, fm801ch_getptr),
534 KOBJMETHOD(channel_getcaps, fm801ch_getcaps),
535 DEVMETHOD_END
536 };
537 CHANNEL_DECLARE(fm801ch);
538
539 /* -------------------------------------------------------------------- */
540
541 /*
542 * Init routine is taken from an original NetBSD driver
543 */
544 static int
fm801_init(struct fm801_info * fm801)545 fm801_init(struct fm801_info *fm801)
546 {
547 u_int32_t k1;
548
549 /* reset codec */
550 fm801_wr(fm801, FM_CODEC_CTL, 0x0020,2);
551 DELAY(100000);
552 fm801_wr(fm801, FM_CODEC_CTL, 0x0000,2);
553 DELAY(100000);
554
555 fm801_wr(fm801, FM_PCM_VOLUME, 0x0808,2);
556 fm801_wr(fm801, FM_FM_VOLUME, 0x0808,2);
557 fm801_wr(fm801, FM_I2S_VOLUME, 0x0808,2);
558 fm801_wr(fm801, 0x40,0x107f,2); /* enable legacy audio */
559
560 fm801_wr((void *)fm801, FM_RECORD_SOURCE, 0x0000,2);
561
562 /* Unmask playback, record and mpu interrupts, mask the rest */
563 k1 = fm801_rd((void *)fm801, FM_INTMASK,2);
564 fm801_wr(fm801, FM_INTMASK,
565 (k1 & ~(FM_INTMASK_PLAY | FM_INTMASK_REC | FM_INTMASK_MPU)) |
566 FM_INTMASK_VOL,2);
567 fm801_wr(fm801, FM_INTSTATUS,
568 FM_INTSTATUS_PLAY | FM_INTSTATUS_REC | FM_INTSTATUS_MPU |
569 FM_INTSTATUS_VOL,2);
570
571 DPRINT("FM801 init Ok\n");
572 return 0;
573 }
574
575 static int
fm801_pci_attach(device_t dev)576 fm801_pci_attach(device_t dev)
577 {
578 struct ac97_info *codec = NULL;
579 struct fm801_info *fm801;
580 int i;
581 int mapped = 0;
582 char status[SND_STATUSLEN];
583
584 fm801 = malloc(sizeof(*fm801), M_DEVBUF, M_WAITOK | M_ZERO);
585 fm801->type = pci_get_devid(dev);
586
587 pci_enable_busmaster(dev);
588
589 for (i = 0; (mapped == 0) && (i < PCI_MAXMAPS_0); i++) {
590 fm801->regid = PCIR_BAR(i);
591 fm801->regtype = SYS_RES_MEMORY;
592 fm801->reg = bus_alloc_resource_any(dev, fm801->regtype,
593 &fm801->regid, RF_ACTIVE);
594 if(!fm801->reg)
595 {
596 fm801->regtype = SYS_RES_IOPORT;
597 fm801->reg = bus_alloc_resource_any(dev,
598 fm801->regtype,
599 &fm801->regid,
600 RF_ACTIVE);
601 }
602
603 if(fm801->reg) {
604 fm801->st = rman_get_bustag(fm801->reg);
605 fm801->sh = rman_get_bushandle(fm801->reg);
606 mapped++;
607 }
608 }
609
610 if (mapped == 0) {
611 device_printf(dev, "unable to map register space\n");
612 goto oops;
613 }
614
615 fm801->bufsz = pcm_getbuffersize(dev, 4096, FM801_DEFAULT_BUFSZ, 65536);
616
617 fm801_init(fm801);
618
619 codec = AC97_CREATE(dev, fm801, fm801_ac97);
620 if (codec == NULL) goto oops;
621
622 if (mixer_init(dev, ac97_getmixerclass(), codec) == -1) goto oops;
623
624 fm801->irqid = 0;
625 fm801->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &fm801->irqid,
626 RF_ACTIVE | RF_SHAREABLE);
627 if (!fm801->irq ||
628 snd_setup_intr(dev, fm801->irq, 0, fm801_intr, fm801, &fm801->ih)) {
629 device_printf(dev, "unable to map interrupt\n");
630 goto oops;
631 }
632
633 if (bus_dma_tag_create(/*parent*/bus_get_dma_tag(dev), /*alignment*/2,
634 /*boundary*/0,
635 /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
636 /*highaddr*/BUS_SPACE_MAXADDR,
637 /*filter*/NULL, /*filterarg*/NULL,
638 /*maxsize*/fm801->bufsz, /*nsegments*/1, /*maxsegz*/0x3ffff,
639 /*flags*/0, /*lockfunc*/busdma_lock_mutex,
640 /*lockarg*/&Giant, &fm801->parent_dmat) != 0) {
641 device_printf(dev, "unable to create dma tag\n");
642 goto oops;
643 }
644
645 snprintf(status, 64, "at %s 0x%jx irq %jd %s",
646 (fm801->regtype == SYS_RES_IOPORT)? "io" : "memory",
647 rman_get_start(fm801->reg), rman_get_start(fm801->irq),PCM_KLDSTRING(snd_fm801));
648
649 #define FM801_MAXPLAYCH 1
650 if (pcm_register(dev, fm801, FM801_MAXPLAYCH, 1)) goto oops;
651 pcm_addchan(dev, PCMDIR_PLAY, &fm801ch_class, fm801);
652 pcm_addchan(dev, PCMDIR_REC, &fm801ch_class, fm801);
653 pcm_setstatus(dev, status);
654
655 fm801->radio = device_add_child(dev, "radio", -1);
656 bus_generic_attach(dev);
657
658 return 0;
659
660 oops:
661 if (codec) ac97_destroy(codec);
662 if (fm801->reg) bus_release_resource(dev, fm801->regtype, fm801->regid, fm801->reg);
663 if (fm801->ih) bus_teardown_intr(dev, fm801->irq, fm801->ih);
664 if (fm801->irq) bus_release_resource(dev, SYS_RES_IRQ, fm801->irqid, fm801->irq);
665 if (fm801->parent_dmat) bus_dma_tag_destroy(fm801->parent_dmat);
666 free(fm801, M_DEVBUF);
667 return ENXIO;
668 }
669
670 static int
fm801_pci_detach(device_t dev)671 fm801_pci_detach(device_t dev)
672 {
673 int r;
674 struct fm801_info *fm801;
675
676 DPRINT("Forte Media FM801 detach\n");
677
678 fm801 = pcm_getdevinfo(dev);
679
680 r = bus_generic_detach(dev);
681 if (r)
682 return r;
683 if (fm801->radio != NULL) {
684 r = device_delete_child(dev, fm801->radio);
685 if (r)
686 return r;
687 fm801->radio = NULL;
688 }
689
690 r = pcm_unregister(dev);
691 if (r)
692 return r;
693
694 bus_release_resource(dev, fm801->regtype, fm801->regid, fm801->reg);
695 bus_teardown_intr(dev, fm801->irq, fm801->ih);
696 bus_release_resource(dev, SYS_RES_IRQ, fm801->irqid, fm801->irq);
697 bus_dma_tag_destroy(fm801->parent_dmat);
698 free(fm801, M_DEVBUF);
699 return 0;
700 }
701
702 static int
fm801_pci_probe(device_t dev)703 fm801_pci_probe( device_t dev )
704 {
705 int id;
706
707 if ((id = pci_get_devid(dev)) == PCI_DEVICE_FORTEMEDIA1 ) {
708 device_set_desc(dev, "Forte Media FM801 Audio Controller");
709 return BUS_PROBE_DEFAULT;
710 }
711 /*
712 if ((id = pci_get_devid(dev)) == PCI_DEVICE_FORTEMEDIA2 ) {
713 device_set_desc(dev, "Forte Media FM801 Joystick (Not Supported)");
714 return ENXIO;
715 }
716 */
717 return ENXIO;
718 }
719
720 static struct resource *
fm801_alloc_resource(device_t bus,device_t child,int type,int * rid,rman_res_t start,rman_res_t end,rman_res_t count,u_int flags)721 fm801_alloc_resource(device_t bus, device_t child, int type, int *rid,
722 rman_res_t start, rman_res_t end, rman_res_t count,
723 u_int flags)
724 {
725 struct fm801_info *fm801;
726
727 fm801 = pcm_getdevinfo(bus);
728
729 if (type == SYS_RES_IOPORT && *rid == PCIR_BAR(0))
730 return (fm801->reg);
731
732 return (NULL);
733 }
734
735 static int
fm801_release_resource(device_t bus,device_t child,int type,int rid,struct resource * r)736 fm801_release_resource(device_t bus, device_t child, int type, int rid,
737 struct resource *r)
738 {
739 return (0);
740 }
741
742 static device_method_t fm801_methods[] = {
743 /* Device interface */
744 DEVMETHOD(device_probe, fm801_pci_probe),
745 DEVMETHOD(device_attach, fm801_pci_attach),
746 DEVMETHOD(device_detach, fm801_pci_detach),
747 DEVMETHOD(device_shutdown, bus_generic_shutdown),
748 DEVMETHOD(device_suspend, bus_generic_suspend),
749 DEVMETHOD(device_resume, bus_generic_resume),
750
751 /* Bus interface */
752 DEVMETHOD(bus_alloc_resource, fm801_alloc_resource),
753 DEVMETHOD(bus_release_resource, fm801_release_resource),
754 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
755 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
756
757 DEVMETHOD_END
758 };
759
760 static driver_t fm801_driver = {
761 "pcm",
762 fm801_methods,
763 PCM_SOFTC_SIZE,
764 };
765
766 DRIVER_MODULE(snd_fm801, pci, fm801_driver, pcm_devclass, 0, 0);
767 MODULE_DEPEND(snd_fm801, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
768 MODULE_VERSION(snd_fm801, 1);
769