]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/staging/intel_sst/intelmid.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix common misspellings
[mirror_ubuntu-bionic-kernel.git] / drivers / staging / intel_sst / intelmid.c
1 /*
2 * intelmid.c - Intel Sound card driver for MID
3 *
4 * Copyright (C) 2008-10 Intel Corp
5 * Authors: Harsha Priya <priya.harsha@intel.com>
6 * Vinod Koul <vinod.koul@intel.com>
7 * Dharageswari R <dharageswari.r@intel.com>
8 * KP Jeeja <jeeja.kp@intel.com>
9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; version 2 of the License.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, write to the Free Software Foundation, Inc.,
22 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23 *
24 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 * ALSA driver for Intel MID sound card chipset
26 */
27
28 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29
30 #include <linux/slab.h>
31 #include <linux/io.h>
32 #include <linux/platform_device.h>
33 #include <linux/interrupt.h>
34 #include <linux/sched.h>
35 #include <sound/control.h>
36 #include <asm/mrst.h>
37 #include <sound/pcm.h>
38 #include "jack.h"
39 #include <sound/pcm_params.h>
40 #include <sound/initval.h>
41 #include "intel_sst.h"
42 #include "intel_sst_ioctl.h"
43 #include "intelmid_snd_control.h"
44 #include "intelmid.h"
45
46 MODULE_AUTHOR("Vinod Koul <vinod.koul@intel.com>");
47 MODULE_AUTHOR("Harsha Priya <priya.harsha@intel.com>");
48 MODULE_AUTHOR("Dharageswari R <dharageswari.r@intel.com>");
49 MODULE_AUTHOR("KP Jeeja <jeeja.kp@intel.com>");
50 MODULE_DESCRIPTION("Intel MAD Sound card driver");
51 MODULE_LICENSE("GPL v2");
52 MODULE_SUPPORTED_DEVICE("{Intel,Intel_MAD}");
53
54
55 static int card_index = SNDRV_DEFAULT_IDX1;/* Index 0-MAX */
56 static char *card_id = SNDRV_DEFAULT_STR1; /* ID for this card */
57
58 module_param(card_index, int, 0444);
59 MODULE_PARM_DESC(card_index, "Index value for INTELMAD soundcard.");
60 module_param(card_id, charp, 0444);
61 MODULE_PARM_DESC(card_id, "ID string for INTELMAD soundcard.");
62
63 int sst_card_vendor_id;
64 int intelmid_audio_interrupt_enable;/*checkpatch fix*/
65
66 /* Data path functionalities */
67 static struct snd_pcm_hardware snd_intelmad_stream = {
68 .info = (SNDRV_PCM_INFO_INTERLEAVED |
69 SNDRV_PCM_INFO_DOUBLE |
70 SNDRV_PCM_INFO_PAUSE |
71 SNDRV_PCM_INFO_RESUME |
72 SNDRV_PCM_INFO_MMAP|
73 SNDRV_PCM_INFO_MMAP_VALID |
74 SNDRV_PCM_INFO_BLOCK_TRANSFER |
75 SNDRV_PCM_INFO_SYNC_START),
76 .formats = (SNDRV_PCM_FMTBIT_S16 | SNDRV_PCM_FMTBIT_U16 |
77 SNDRV_PCM_FMTBIT_S24 | SNDRV_PCM_FMTBIT_U24 |
78 SNDRV_PCM_FMTBIT_S32 | SNDRV_PCM_FMTBIT_U32),
79 .rates = (SNDRV_PCM_RATE_8000|
80 SNDRV_PCM_RATE_44100 |
81 SNDRV_PCM_RATE_48000),
82 .rate_min = MIN_RATE,
83
84 .rate_max = MAX_RATE,
85 .channels_min = MIN_CHANNEL,
86 .channels_max = MAX_CHANNEL_AMIC,
87 .buffer_bytes_max = MAX_BUFFER,
88 .period_bytes_min = MIN_PERIOD_BYTES,
89 .period_bytes_max = MAX_PERIOD_BYTES,
90 .periods_min = MIN_PERIODS,
91 .periods_max = MAX_PERIODS,
92 .fifo_size = FIFO_SIZE,
93 };
94
95
96 /**
97 * snd_intelmad_pcm_trigger - stream activities are handled here
98 *
99 * @substream:substream for which the stream function is called
100 * @cmd:the stream commamd that requested from upper layer
101 *
102 * This function is called whenever an a stream activity is invoked
103 */
104 static int snd_intelmad_pcm_trigger(struct snd_pcm_substream *substream,
105 int cmd)
106 {
107 int ret_val = 0, str_id;
108 struct snd_intelmad *intelmaddata;
109 struct mad_stream_pvt *stream;
110 struct intel_sst_pcm_control *sst_ops;
111
112 WARN_ON(!substream);
113
114 intelmaddata = snd_pcm_substream_chip(substream);
115 stream = substream->runtime->private_data;
116
117 WARN_ON(!intelmaddata->sstdrv_ops);
118 WARN_ON(!intelmaddata->sstdrv_ops->scard_ops);
119 sst_ops = intelmaddata->sstdrv_ops->pcm_control;
120 str_id = stream->stream_info.str_id;
121
122 switch (cmd) {
123 case SNDRV_PCM_TRIGGER_START:
124 pr_debug("Trigger Start\n");
125 ret_val = sst_ops->device_control(SST_SND_START, &str_id);
126 if (ret_val)
127 return ret_val;
128 stream->stream_status = RUNNING;
129 stream->substream = substream;
130 break;
131 case SNDRV_PCM_TRIGGER_STOP:
132 pr_debug("in stop\n");
133 ret_val = sst_ops->device_control(SST_SND_DROP, &str_id);
134 if (ret_val)
135 return ret_val;
136 stream->stream_status = DROPPED;
137 break;
138 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
139 pr_debug("in pause\n");
140 ret_val = sst_ops->device_control(SST_SND_PAUSE, &str_id);
141 if (ret_val)
142 return ret_val;
143 stream->stream_status = PAUSED;
144 break;
145 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
146 pr_debug("in pause release\n");
147 ret_val = sst_ops->device_control(SST_SND_RESUME, &str_id);
148 if (ret_val)
149 return ret_val;
150 stream->stream_status = RUNNING;
151 break;
152 default:
153 return -EINVAL;
154 }
155 return ret_val;
156 }
157
158 /**
159 * snd_intelmad_pcm_prepare- internal preparation before starting a stream
160 *
161 * @substream: substream for which the function is called
162 *
163 * This function is called when a stream is started for internal preparation.
164 */
165 static int snd_intelmad_pcm_prepare(struct snd_pcm_substream *substream)
166 {
167 struct mad_stream_pvt *stream;
168 int ret_val = 0;
169 struct snd_intelmad *intelmaddata;
170
171 pr_debug("pcm_prepare called\n");
172
173 WARN_ON(!substream);
174 stream = substream->runtime->private_data;
175 intelmaddata = snd_pcm_substream_chip(substream);
176 pr_debug("pb cnt = %d cap cnt = %d\n",\
177 intelmaddata->playback_cnt,
178 intelmaddata->capture_cnt);
179
180 if (stream->stream_info.str_id) {
181 pr_debug("Prepare called for already set stream\n");
182 ret_val = intelmaddata->sstdrv_ops->pcm_control->device_control(
183 SST_SND_DROP, &stream->stream_info.str_id);
184 return ret_val;
185 }
186
187 ret_val = snd_intelmad_alloc_stream(substream);
188 if (ret_val < 0)
189 return ret_val;
190 stream->dbg_cum_bytes = 0;
191 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
192 intelmaddata->playback_cnt++;
193 else
194 intelmaddata->capture_cnt++;
195 /* return back the stream id */
196 snprintf(substream->pcm->id, sizeof(substream->pcm->id),
197 "%d", stream->stream_info.str_id);
198 pr_debug("stream id to user = %s\n",
199 substream->pcm->id);
200
201 ret_val = snd_intelmad_init_stream(substream);
202 if (ret_val)
203 return ret_val;
204 substream->runtime->hw.info = SNDRV_PCM_INFO_BLOCK_TRANSFER;
205 return ret_val;
206 }
207
208 static int snd_intelmad_hw_params(struct snd_pcm_substream *substream,
209 struct snd_pcm_hw_params *hw_params)
210 {
211 int ret_val;
212
213 pr_debug("snd_intelmad_hw_params called\n");
214 ret_val = snd_pcm_lib_malloc_pages(substream,
215 params_buffer_bytes(hw_params));
216 memset(substream->runtime->dma_area, 0,
217 params_buffer_bytes(hw_params));
218
219 return ret_val;
220 }
221
222 static int snd_intelmad_hw_free(struct snd_pcm_substream *substream)
223 {
224 pr_debug("snd_intelmad_hw_free called\n");
225 return snd_pcm_lib_free_pages(substream);
226 }
227
228 /**
229 * snd_intelmad_pcm_pointer- to send the current buffer pointer processed by hw
230 *
231 * @substream: substream for which the function is called
232 *
233 * This function is called by ALSA framework to get the current hw buffer ptr
234 * when a period is elapsed
235 */
236 static snd_pcm_uframes_t snd_intelmad_pcm_pointer
237 (struct snd_pcm_substream *substream)
238 {
239 /* struct snd_pcm_runtime *runtime = substream->runtime; */
240 struct mad_stream_pvt *stream;
241 struct snd_intelmad *intelmaddata;
242 int ret_val;
243
244 WARN_ON(!substream);
245
246 intelmaddata = snd_pcm_substream_chip(substream);
247 stream = substream->runtime->private_data;
248 if (stream->stream_status == INIT)
249 return 0;
250
251 ret_val = intelmaddata->sstdrv_ops->pcm_control->device_control(
252 SST_SND_BUFFER_POINTER, &stream->stream_info);
253 if (ret_val) {
254 pr_err("error code = 0x%x\n", ret_val);
255 return ret_val;
256 }
257 pr_debug("samples reported out 0x%llx\n",
258 stream->stream_info.buffer_ptr);
259 pr_debug("Frame bits:: %d period_count :: %d\n",
260 (int)substream->runtime->frame_bits,
261 (int)substream->runtime->period_size);
262
263 return stream->stream_info.buffer_ptr;
264
265 }
266
267 /**
268 * snd_intelmad_close- to free parameteres when stream is stopped
269 *
270 * @substream: substream for which the function is called
271 *
272 * This function is called by ALSA framework when stream is stopped
273 */
274 static int snd_intelmad_close(struct snd_pcm_substream *substream)
275 {
276 struct snd_intelmad *intelmaddata;
277 struct mad_stream_pvt *stream;
278 int ret_val = 0, str_id;
279
280 WARN_ON(!substream);
281
282 stream = substream->runtime->private_data;
283 str_id = stream->stream_info.str_id;
284
285 pr_debug("sst: snd_intelmad_close called for %d\n", str_id);
286 intelmaddata = snd_pcm_substream_chip(substream);
287
288 pr_debug("str id = %d\n", stream->stream_info.str_id);
289 if (stream->stream_info.str_id) {
290 /* SST API to actually stop/free the stream */
291 ret_val = intelmaddata->sstdrv_ops->pcm_control->close(str_id);
292 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
293 intelmaddata->playback_cnt--;
294 else
295 intelmaddata->capture_cnt--;
296 }
297 pr_debug("snd_intelmad_close : pb cnt = %d cap cnt = %d\n",
298 intelmaddata->playback_cnt, intelmaddata->capture_cnt);
299 kfree(substream->runtime->private_data);
300 return ret_val;
301 }
302
303 /**
304 * snd_intelmad_open- to set runtime parameters during stream start
305 *
306 * @substream: substream for which the function is called
307 * @type: audio device type
308 *
309 * This function is called by ALSA framework when stream is started
310 */
311 static int snd_intelmad_open(struct snd_pcm_substream *substream,
312 enum snd_sst_audio_device_type type)
313 {
314 struct snd_intelmad *intelmaddata;
315 struct snd_pcm_runtime *runtime;
316 struct mad_stream_pvt *stream;
317
318 WARN_ON(!substream);
319
320 pr_debug("snd_intelmad_open called\n");
321
322 intelmaddata = snd_pcm_substream_chip(substream);
323 runtime = substream->runtime;
324 /* set the runtime hw parameter with local snd_pcm_hardware struct */
325 runtime->hw = snd_intelmad_stream;
326 if (intelmaddata->cpu_id == CPU_CHIP_PENWELL) {
327 runtime->hw = snd_intelmad_stream;
328 runtime->hw.rates = SNDRV_PCM_RATE_48000;
329 runtime->hw.rate_min = MAX_RATE;
330 runtime->hw.formats = (SNDRV_PCM_FMTBIT_S24 |
331 SNDRV_PCM_FMTBIT_U24);
332 if (intelmaddata->sstdrv_ops->scard_ops->input_dev_id == AMIC)
333 runtime->hw.channels_max = MAX_CHANNEL_AMIC;
334 else
335 runtime->hw.channels_max = MAX_CHANNEL_DMIC;
336
337 }
338 /* setup the internal datastruture stream pointers based on it being
339 playback or capture stream */
340 stream = kzalloc(sizeof(*stream), GFP_KERNEL);
341 if (!stream)
342 return -ENOMEM;
343 stream->stream_info.str_id = 0;
344 stream->device = type;
345 stream->stream_status = INIT;
346 runtime->private_data = stream;
347 return snd_pcm_hw_constraint_integer(runtime,
348 SNDRV_PCM_HW_PARAM_PERIODS);
349 }
350
351 static int snd_intelmad_headset_open(struct snd_pcm_substream *substream)
352 {
353 return snd_intelmad_open(substream, SND_SST_DEVICE_HEADSET);
354 }
355
356 static int snd_intelmad_ihf_open(struct snd_pcm_substream *substream)
357 {
358 return snd_intelmad_open(substream, SND_SST_DEVICE_IHF);
359 }
360
361 static int snd_intelmad_vibra_open(struct snd_pcm_substream *substream)
362 {
363 return snd_intelmad_open(substream, SND_SST_DEVICE_VIBRA);
364 }
365
366 static int snd_intelmad_haptic_open(struct snd_pcm_substream *substream)
367 {
368 return snd_intelmad_open(substream, SND_SST_DEVICE_HAPTIC);
369 }
370
371 static struct snd_pcm_ops snd_intelmad_headset_ops = {
372 .open = snd_intelmad_headset_open,
373 .close = snd_intelmad_close,
374 .ioctl = snd_pcm_lib_ioctl,
375 .hw_params = snd_intelmad_hw_params,
376 .hw_free = snd_intelmad_hw_free,
377 .prepare = snd_intelmad_pcm_prepare,
378 .trigger = snd_intelmad_pcm_trigger,
379 .pointer = snd_intelmad_pcm_pointer,
380 };
381
382 static struct snd_pcm_ops snd_intelmad_ihf_ops = {
383 .open = snd_intelmad_ihf_open,
384 .close = snd_intelmad_close,
385 .ioctl = snd_pcm_lib_ioctl,
386 .hw_params = snd_intelmad_hw_params,
387 .hw_free = snd_intelmad_hw_free,
388 .prepare = snd_intelmad_pcm_prepare,
389 .trigger = snd_intelmad_pcm_trigger,
390 .pointer = snd_intelmad_pcm_pointer,
391 };
392
393 static struct snd_pcm_ops snd_intelmad_vibra_ops = {
394 .open = snd_intelmad_vibra_open,
395 .close = snd_intelmad_close,
396 .ioctl = snd_pcm_lib_ioctl,
397 .hw_params = snd_intelmad_hw_params,
398 .hw_free = snd_intelmad_hw_free,
399 .prepare = snd_intelmad_pcm_prepare,
400 .trigger = snd_intelmad_pcm_trigger,
401 .pointer = snd_intelmad_pcm_pointer,
402 };
403
404 static struct snd_pcm_ops snd_intelmad_haptic_ops = {
405 .open = snd_intelmad_haptic_open,
406 .close = snd_intelmad_close,
407 .ioctl = snd_pcm_lib_ioctl,
408 .hw_params = snd_intelmad_hw_params,
409 .hw_free = snd_intelmad_hw_free,
410 .prepare = snd_intelmad_pcm_prepare,
411 .trigger = snd_intelmad_pcm_trigger,
412 .pointer = snd_intelmad_pcm_pointer,
413 };
414
415 static struct snd_pcm_ops snd_intelmad_capture_ops = {
416 .open = snd_intelmad_headset_open,
417 .close = snd_intelmad_close,
418 .ioctl = snd_pcm_lib_ioctl,
419 .hw_params = snd_intelmad_hw_params,
420 .hw_free = snd_intelmad_hw_free,
421 .prepare = snd_intelmad_pcm_prepare,
422 .trigger = snd_intelmad_pcm_trigger,
423 .pointer = snd_intelmad_pcm_pointer,
424 };
425
426
427 /**
428 * snd_intelmad_intr_handler- interrupt handler
429 *
430 * @irq : irq number of the interrupt received
431 * @dev: device context
432 *
433 * This function is called when an interrupt is raised at the sound card
434 */
435 static irqreturn_t snd_intelmad_intr_handler(int irq, void *dev)
436 {
437 struct snd_intelmad *intelmaddata =
438 (struct snd_intelmad *)dev;
439 u8 intsts;
440
441 memcpy_fromio(&intsts,
442 ((void *)(intelmaddata->int_base)),
443 sizeof(u8));
444 intelmaddata->mad_jack_msg.intsts = intsts;
445 intelmaddata->mad_jack_msg.intelmaddata = intelmaddata;
446
447 queue_work(intelmaddata->mad_jack_wq, &intelmaddata->mad_jack_msg.wq);
448
449 return IRQ_HANDLED;
450 }
451
452 void sst_mad_send_jack_report(struct snd_jack *jack,
453 int buttonpressevent , int status)
454 {
455
456 if (!jack) {
457 pr_debug("MAD error jack empty\n");
458
459 } else {
460 pr_debug("MAD send jack report for = %d!!!\n", status);
461 pr_debug("MAD send jack report %d\n", jack->type);
462 snd_jack_report(jack, status);
463
464 /*button pressed and released */
465 if (buttonpressevent)
466 snd_jack_report(jack, 0);
467 pr_debug("MAD sending jack report Done !!!\n");
468 }
469
470
471
472 }
473
474 void sst_mad_jackdetection_fs(u8 intsts , struct snd_intelmad *intelmaddata)
475 {
476 struct snd_jack *jack = NULL;
477 unsigned int present = 0, jack_event_flag = 0, buttonpressflag = 0;
478 struct sc_reg_access sc_access[] = {
479 {0x187, 0x00, MASK7},
480 {0x188, 0x10, MASK4},
481 {0x18b, 0x10, MASK4},
482 };
483
484 struct sc_reg_access sc_access_write[] = {
485 {0x198, 0x00, 0x0},
486 };
487
488 if (intsts & 0x4) {
489
490 if (!(intelmid_audio_interrupt_enable)) {
491 pr_debug("Audio interrupt enable\n");
492 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
493
494 sst_sc_reg_access(sc_access_write, PMIC_WRITE, 1);
495 intelmid_audio_interrupt_enable = 1;
496 intelmaddata->jack[0].jack_status = 0;
497 intelmaddata->jack[1].jack_status = 0;
498
499 }
500 /* send headphone detect */
501 pr_debug("MAD headphone %d\n", intsts & 0x4);
502 jack = &intelmaddata->jack[0].jack;
503 present = !(intelmaddata->jack[0].jack_status);
504 intelmaddata->jack[0].jack_status = present;
505 jack_event_flag = 1;
506
507 }
508
509 if (intsts & 0x2) {
510 /* send short push */
511 pr_debug("MAD short push %d\n", intsts & 0x2);
512 jack = &intelmaddata->jack[2].jack;
513 present = 1;
514 jack_event_flag = 1;
515 buttonpressflag = 1;
516 }
517 if (intsts & 0x1) {
518 /* send long push */
519 pr_debug("MAD long push %d\n", intsts & 0x1);
520 jack = &intelmaddata->jack[3].jack;
521 present = 1;
522 jack_event_flag = 1;
523 buttonpressflag = 1;
524 }
525 if (intsts & 0x8) {
526 if (!(intelmid_audio_interrupt_enable)) {
527 pr_debug("Audio interrupt enable\n");
528 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
529
530 sst_sc_reg_access(sc_access_write, PMIC_WRITE, 1);
531 intelmid_audio_interrupt_enable = 1;
532 intelmaddata->jack[0].jack_status = 0;
533 intelmaddata->jack[1].jack_status = 0;
534 }
535 /* send headset detect */
536 pr_debug("MAD headset = %d\n", intsts & 0x8);
537 jack = &intelmaddata->jack[1].jack;
538 present = !(intelmaddata->jack[1].jack_status);
539 intelmaddata->jack[1].jack_status = present;
540 jack_event_flag = 1;
541 }
542
543 if (jack_event_flag)
544 sst_mad_send_jack_report(jack, buttonpressflag, present);
545 }
546
547
548 void sst_mad_jackdetection_mx(u8 intsts, struct snd_intelmad *intelmaddata)
549 {
550 u8 value = 0, jack_prev_state = 0;
551 struct snd_jack *jack = NULL;
552 unsigned int present = 0, jack_event_flag = 0, buttonpressflag = 0;
553 time_t timediff;
554 struct sc_reg_access sc_access_read = {0,};
555 struct snd_pmic_ops *scard_ops;
556
557 scard_ops = intelmaddata->sstdrv_ops->scard_ops;
558
559 pr_debug("previous value: %x\n", intelmaddata->jack_prev_state);
560
561 if (!(intelmid_audio_interrupt_enable)) {
562 pr_debug("Audio interrupt enable\n");
563 intelmaddata->jack_prev_state = 0xC0;
564 intelmid_audio_interrupt_enable = 1;
565 }
566
567 if (intsts & 0x2) {
568 jack_prev_state = intelmaddata->jack_prev_state;
569 if (intelmaddata->pmic_status == PMIC_INIT) {
570 sc_access_read.reg_addr = 0x201;
571 sst_sc_reg_access(&sc_access_read, PMIC_READ, 1);
572 value = (sc_access_read.value);
573 pr_debug("value returned = 0x%x\n", value);
574 }
575
576 if (jack_prev_state == 0xc0 && value == 0x40) {
577 /*headset detected. */
578 pr_debug("MAD headset inserted\n");
579 jack = &intelmaddata->jack[1].jack;
580 present = 1;
581 jack_event_flag = 1;
582 intelmaddata->jack[1].jack_status = 1;
583
584 }
585
586 if (jack_prev_state == 0xc0 && value == 0x00) {
587 /* headphone detected. */
588 pr_debug("MAD headphone inserted\n");
589 jack = &intelmaddata->jack[0].jack;
590 present = 1;
591 jack_event_flag = 1;
592
593 }
594
595 if (jack_prev_state == 0x40 && value == 0xc0) {
596 /*headset removed*/
597 pr_debug("Jack headset status %d\n",
598 intelmaddata->jack[1].jack_status);
599 pr_debug("MAD headset removed\n");
600 jack = &intelmaddata->jack[1].jack;
601 present = 0;
602 jack_event_flag = 1;
603 intelmaddata->jack[1].jack_status = 0;
604 }
605
606 if (jack_prev_state == 0x00 && value == 0xc0) {
607 /* headphone detected. */
608 pr_debug("Jack headphone status %d\n",
609 intelmaddata->jack[0].jack_status);
610 pr_debug("headphone removed\n");
611 jack = &intelmaddata->jack[0].jack;
612 present = 0;
613 jack_event_flag = 1;
614 }
615
616 if (jack_prev_state == 0x40 && value == 0x00) {
617 /*button pressed*/
618 do_gettimeofday(&intelmaddata->jack[1].buttonpressed);
619 pr_debug("MAD button press detected\n");
620 }
621
622
623 if (jack_prev_state == 0x00 && value == 0x40) {
624 if (intelmaddata->jack[1].jack_status) {
625 /*button pressed*/
626 do_gettimeofday(
627 &intelmaddata->jack[1].buttonreleased);
628 /*button pressed */
629 pr_debug("Button Released detected\n");
630 timediff = intelmaddata->jack[1].
631 buttonreleased.tv_sec - intelmaddata->
632 jack[1].buttonpressed.tv_sec;
633 buttonpressflag = 1;
634 if (timediff > 1) {
635 pr_debug("long press detected\n");
636 /* send headphone detect/undetect */
637 jack = &intelmaddata->jack[3].jack;
638 present = 1;
639 jack_event_flag = 1;
640 } else {
641 pr_debug("short press detected\n");
642 /* send headphone detect/undetect */
643 jack = &intelmaddata->jack[2].jack;
644 present = 1;
645 jack_event_flag = 1;
646 }
647 }
648
649 }
650 intelmaddata->jack_prev_state = value;
651 }
652 if (jack_event_flag)
653 sst_mad_send_jack_report(jack, buttonpressflag, present);
654 }
655
656
657 void sst_mad_jackdetection_nec(u8 intsts, struct snd_intelmad *intelmaddata)
658 {
659 u8 value = 0;
660 struct snd_jack *jack = NULL;
661 unsigned int present = 0, jack_event_flag = 0, buttonpressflag = 0;
662 struct sc_reg_access sc_access_read = {0,};
663
664 if (intelmaddata->pmic_status == PMIC_INIT) {
665 sc_access_read.reg_addr = 0x132;
666 sst_sc_reg_access(&sc_access_read, PMIC_READ, 1);
667 value = (sc_access_read.value);
668 pr_debug("value returned = 0x%x\n", value);
669 }
670 if (intsts & 0x1) {
671 pr_debug("headset detected\n");
672 /* send headset detect/undetect */
673 jack = &intelmaddata->jack[1].jack;
674 present = (value == 0x1) ? 1 : 0;
675 jack_event_flag = 1;
676 }
677 if (intsts & 0x2) {
678 pr_debug("headphone detected\n");
679 /* send headphone detect/undetect */
680 jack = &intelmaddata->jack[0].jack;
681 present = (value == 0x2) ? 1 : 0;
682 jack_event_flag = 1;
683 }
684 if (intsts & 0x4) {
685 pr_debug("short push detected\n");
686 /* send short push */
687 jack = &intelmaddata->jack[2].jack;
688 present = 1;
689 jack_event_flag = 1;
690 buttonpressflag = 1;
691 }
692 if (intsts & 0x8) {
693 pr_debug("long push detected\n");
694 /* send long push */
695 jack = &intelmaddata->jack[3].jack;
696 present = 1;
697 jack_event_flag = 1;
698 buttonpressflag = 1;
699 }
700
701 if (jack_event_flag)
702 sst_mad_send_jack_report(jack, buttonpressflag, present);
703
704
705 }
706
707 void sst_process_mad_jack_detection(struct work_struct *work)
708 {
709 u8 intsts;
710 struct mad_jack_msg_wq *mad_jack_detect =
711 container_of(work, struct mad_jack_msg_wq, wq);
712
713 struct snd_intelmad *intelmaddata =
714 mad_jack_detect->intelmaddata;
715
716 intsts = mad_jack_detect->intsts;
717
718 switch (intelmaddata->sstdrv_ops->vendor_id) {
719 case SND_FS:
720 sst_mad_jackdetection_fs(intsts , intelmaddata);
721 break;
722 case SND_MX:
723 sst_mad_jackdetection_mx(intsts , intelmaddata);
724 break;
725 case SND_NC:
726 sst_mad_jackdetection_nec(intsts , intelmaddata);
727 break;
728 }
729 }
730
731
732 static int __devinit snd_intelmad_register_irq(
733 struct snd_intelmad *intelmaddata)
734 {
735 int ret_val;
736 u32 regbase = AUDINT_BASE, regsize = 8;
737 char *drv_name;
738
739 pr_debug("irq reg done, regbase 0x%x, regsize 0x%x\n",
740 regbase, regsize);
741 intelmaddata->int_base = ioremap_nocache(regbase, regsize);
742 if (!intelmaddata->int_base)
743 pr_err("Mapping of cache failed\n");
744 pr_debug("irq = 0x%x\n", intelmaddata->irq);
745 if (intelmaddata->cpu_id == CPU_CHIP_PENWELL)
746 drv_name = DRIVER_NAME_MFLD;
747 else
748 drv_name = DRIVER_NAME_MRST;
749 ret_val = request_irq(intelmaddata->irq,
750 snd_intelmad_intr_handler,
751 IRQF_SHARED, drv_name,
752 intelmaddata);
753 if (ret_val)
754 pr_err("cannot register IRQ\n");
755 return ret_val;
756 }
757
758 static int __devinit snd_intelmad_sst_register(
759 struct snd_intelmad *intelmaddata)
760 {
761 int ret_val = 0;
762 struct snd_pmic_ops *intelmad_vendor_ops[MAX_VENDORS] = {
763 &snd_pmic_ops_fs,
764 &snd_pmic_ops_mx,
765 &snd_pmic_ops_nc,
766 &snd_msic_ops
767 };
768
769 struct sc_reg_access vendor_addr = {0x00, 0x00, 0x00};
770
771 if (intelmaddata->cpu_id == CPU_CHIP_LINCROFT) {
772 ret_val = sst_sc_reg_access(&vendor_addr, PMIC_READ, 1);
773 if (ret_val)
774 return ret_val;
775 sst_card_vendor_id = (vendor_addr.value & (MASK2|MASK1|MASK0));
776 pr_debug("original n extrated vendor id = 0x%x %d\n",
777 vendor_addr.value, sst_card_vendor_id);
778 if (sst_card_vendor_id < 0 || sst_card_vendor_id > 2) {
779 pr_err("vendor card not supported!!\n");
780 return -EIO;
781 }
782 } else
783 sst_card_vendor_id = 0x3;
784
785 intelmaddata->sstdrv_ops->module_name = SST_CARD_NAMES;
786 intelmaddata->sstdrv_ops->vendor_id = sst_card_vendor_id;
787 BUG_ON(!intelmad_vendor_ops[sst_card_vendor_id]);
788 intelmaddata->sstdrv_ops->scard_ops =
789 intelmad_vendor_ops[sst_card_vendor_id];
790
791 if (intelmaddata->cpu_id == CPU_CHIP_PENWELL) {
792 intelmaddata->sstdrv_ops->scard_ops->pb_on = 0;
793 intelmaddata->sstdrv_ops->scard_ops->cap_on = 0;
794 intelmaddata->sstdrv_ops->scard_ops->input_dev_id = DMIC;
795 intelmaddata->sstdrv_ops->scard_ops->output_dev_id =
796 STEREO_HEADPHONE;
797 }
798
799 /* registering with SST driver to get access to SST APIs to use */
800 ret_val = register_sst_card(intelmaddata->sstdrv_ops);
801 if (ret_val) {
802 pr_err("sst card registration failed\n");
803 return ret_val;
804 }
805
806 sst_card_vendor_id = intelmaddata->sstdrv_ops->vendor_id;
807 intelmaddata->pmic_status = PMIC_UNINIT;
808 return ret_val;
809 }
810
811 /* Driver Init/exit functionalities */
812 /**
813 * snd_intelmad_pcm_new - to setup pcm for the card
814 *
815 * @card: pointer to the sound card structure
816 * @intelmaddata: pointer to internal context
817 * @pb: playback count for this card
818 * @cap: capture count for this card
819 * @index: device index
820 *
821 * This function is called from probe function to set up pcm params
822 * and functions
823 */
824 static int __devinit snd_intelmad_pcm_new(struct snd_card *card,
825 struct snd_intelmad *intelmaddata,
826 unsigned int pb, unsigned int cap, unsigned int index)
827 {
828 int ret_val = 0;
829 struct snd_pcm *pcm;
830 char name[32] = INTEL_MAD;
831 struct snd_pcm_ops *pb_ops = NULL, *cap_ops = NULL;
832
833 pr_debug("called for pb %d, cp %d, idx %d\n", pb, cap, index);
834 ret_val = snd_pcm_new(card, name, index, pb, cap, &pcm);
835 if (ret_val)
836 return ret_val;
837 /* setup the ops for playback and capture streams */
838 switch (index) {
839 case 0:
840 pb_ops = &snd_intelmad_headset_ops;
841 cap_ops = &snd_intelmad_capture_ops;
842 break;
843 case 1:
844 pb_ops = &snd_intelmad_ihf_ops;
845 cap_ops = &snd_intelmad_capture_ops;
846 break;
847 case 2:
848 pb_ops = &snd_intelmad_vibra_ops;
849 cap_ops = &snd_intelmad_capture_ops;
850 break;
851 case 3:
852 pb_ops = &snd_intelmad_haptic_ops;
853 cap_ops = &snd_intelmad_capture_ops;
854 break;
855 }
856 if (pb)
857 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, pb_ops);
858 if (cap)
859 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, cap_ops);
860 /* setup private data which can be retrieved when required */
861 pcm->private_data = intelmaddata;
862 pcm->info_flags = 0;
863 strncpy(pcm->name, card->shortname, strlen(card->shortname));
864 /* allocate dma pages for ALSA stream operations */
865 snd_pcm_lib_preallocate_pages_for_all(pcm,
866 SNDRV_DMA_TYPE_CONTINUOUS,
867 snd_dma_continuous_data(GFP_KERNEL),
868 MIN_BUFFER, MAX_BUFFER);
869 return ret_val;
870 }
871
872 static int __devinit snd_intelmad_pcm(struct snd_card *card,
873 struct snd_intelmad *intelmaddata)
874 {
875 int ret_val = 0;
876
877 WARN_ON(!card);
878 WARN_ON(!intelmaddata);
879 pr_debug("snd_intelmad_pcm called\n");
880 ret_val = snd_intelmad_pcm_new(card, intelmaddata, 1, 1, 0);
881 if (intelmaddata->cpu_id == CPU_CHIP_LINCROFT)
882 return ret_val;
883 ret_val = snd_intelmad_pcm_new(card, intelmaddata, 1, 0, 1);
884 if (ret_val)
885 return ret_val;
886 ret_val = snd_intelmad_pcm_new(card, intelmaddata, 1, 0, 2);
887 if (ret_val)
888 return ret_val;
889 return snd_intelmad_pcm_new(card, intelmaddata, 1, 0, 3);
890 }
891
892 /**
893 * snd_intelmad_jack- to setup jack settings of the card
894 *
895 * @intelmaddata: pointer to internal context
896 *
897 * This function is called send jack events
898 */
899 static int snd_intelmad_jack(struct snd_intelmad *intelmaddata)
900 {
901 struct snd_jack *jack;
902 int retval;
903
904 pr_debug("snd_intelmad_jack called\n");
905 jack = &intelmaddata->jack[0].jack;
906 retval = snd_jack_new(intelmaddata->card, "Headphone",
907 SND_JACK_HEADPHONE, &jack);
908 if (retval < 0)
909 return retval;
910 snd_jack_report(jack, 0);
911
912 jack->private_data = jack;
913 intelmaddata->jack[0].jack = *jack;
914
915
916 jack = &intelmaddata->jack[1].jack;
917 retval = snd_jack_new(intelmaddata->card, "Headset",
918 SND_JACK_HEADSET, &jack);
919 if (retval < 0)
920 return retval;
921
922
923
924 jack->private_data = jack;
925 intelmaddata->jack[1].jack = *jack;
926
927
928 jack = &intelmaddata->jack[2].jack;
929 retval = snd_jack_new(intelmaddata->card, "Short Press",
930 SND_JACK_HS_SHORT_PRESS, &jack);
931 if (retval < 0)
932 return retval;
933
934
935 jack->private_data = jack;
936 intelmaddata->jack[2].jack = *jack;
937
938
939 jack = &intelmaddata->jack[3].jack;
940 retval = snd_jack_new(intelmaddata->card, "Long Press",
941 SND_JACK_HS_LONG_PRESS, &jack);
942 if (retval < 0)
943 return retval;
944
945
946 jack->private_data = jack;
947 intelmaddata->jack[3].jack = *jack;
948
949 return retval;
950 }
951
952 /**
953 * snd_intelmad_mixer- to setup mixer settings of the card
954 *
955 * @intelmaddata: pointer to internal context
956 *
957 * This function is called from probe function to set up mixer controls
958 */
959 static int __devinit snd_intelmad_mixer(struct snd_intelmad *intelmaddata)
960 {
961 struct snd_card *card;
962 unsigned int idx;
963 int ret_val = 0, max_controls = 0;
964 char *mixername = "IntelMAD Controls";
965 struct snd_kcontrol_new *controls;
966
967 WARN_ON(!intelmaddata);
968
969 card = intelmaddata->card;
970 strncpy(card->mixername, mixername, sizeof(card->mixername)-1);
971 /* add all widget controls and expose the same */
972 if (intelmaddata->cpu_id == CPU_CHIP_PENWELL) {
973 max_controls = MAX_CTRL_MFLD;
974 controls = snd_intelmad_controls_mfld;
975 } else {
976 max_controls = MAX_CTRL_MRST;
977 controls = snd_intelmad_controls_mrst;
978 }
979 for (idx = 0; idx < max_controls; idx++) {
980 ret_val = snd_ctl_add(card,
981 snd_ctl_new1(&controls[idx],
982 intelmaddata));
983 pr_debug("mixer[idx]=%d added\n", idx);
984 if (ret_val) {
985 pr_err("in adding of control index = %d\n", idx);
986 break;
987 }
988 }
989 return ret_val;
990 }
991
992 static int snd_intelmad_dev_free(struct snd_device *device)
993 {
994 struct snd_intelmad *intelmaddata;
995
996 WARN_ON(!device);
997
998 intelmaddata = device->device_data;
999
1000 pr_debug("snd_intelmad_dev_free called\n");
1001 snd_card_free(intelmaddata->card);
1002 /*genl_unregister_family(&audio_event_genl_family);*/
1003 unregister_sst_card(intelmaddata->sstdrv_ops);
1004
1005 /* free allocated memory for internal context */
1006 destroy_workqueue(intelmaddata->mad_jack_wq);
1007 kfree(intelmaddata->sstdrv_ops);
1008 kfree(intelmaddata);
1009 return 0;
1010 }
1011
1012 static int __devinit snd_intelmad_create(
1013 struct snd_intelmad *intelmaddata,
1014 struct snd_card *card)
1015 {
1016 int ret_val;
1017 static struct snd_device_ops ops = {
1018 .dev_free = snd_intelmad_dev_free,
1019 };
1020
1021 WARN_ON(!intelmaddata);
1022 WARN_ON(!card);
1023 /* ALSA api to register for the device */
1024 ret_val = snd_device_new(card, SNDRV_DEV_LOWLEVEL, intelmaddata, &ops);
1025 return ret_val;
1026 }
1027
1028 /**
1029 * snd_intelmad_probe- function registred for init
1030 * @pdev : pointer to the device struture
1031 * This function is called when the device is initialized
1032 */
1033 int __devinit snd_intelmad_probe(struct platform_device *pdev)
1034 {
1035 struct snd_card *card;
1036 int ret_val;
1037 struct snd_intelmad *intelmaddata;
1038 const struct platform_device_id *id = platform_get_device_id(pdev);
1039 unsigned int cpu_id = (unsigned int)id->driver_data;
1040
1041 pr_debug("probe for %s cpu_id %d\n", pdev->name, cpu_id);
1042 if (!strcmp(pdev->name, DRIVER_NAME_MRST))
1043 pr_debug("detected MRST\n");
1044 else if (!strcmp(pdev->name, DRIVER_NAME_MFLD))
1045 pr_debug("detected MFLD\n");
1046 else {
1047 pr_err("detected unknown device abort!!\n");
1048 return -EIO;
1049 }
1050 if ((cpu_id < CPU_CHIP_LINCROFT) || (cpu_id > CPU_CHIP_PENWELL)) {
1051 pr_err("detected unknown cpu_id abort!!\n");
1052 return -EIO;
1053 }
1054 /* allocate memory for saving internal context and working */
1055 intelmaddata = kzalloc(sizeof(*intelmaddata), GFP_KERNEL);
1056 if (!intelmaddata) {
1057 pr_debug("mem alloctn fail\n");
1058 return -ENOMEM;
1059 }
1060
1061 /* allocate memory for LPE API set */
1062 intelmaddata->sstdrv_ops = kzalloc(sizeof(struct intel_sst_card_ops),
1063 GFP_KERNEL);
1064 if (!intelmaddata->sstdrv_ops) {
1065 pr_err("mem allocation for ops fail\n");
1066 kfree(intelmaddata);
1067 return -ENOMEM;
1068 }
1069
1070 intelmaddata->cpu_id = cpu_id;
1071 /* create a card instance with ALSA framework */
1072 ret_val = snd_card_create(card_index, card_id, THIS_MODULE, 0, &card);
1073 if (ret_val) {
1074 pr_err("snd_card_create fail\n");
1075 goto free_allocs;
1076 }
1077
1078 intelmaddata->pdev = pdev;
1079 intelmaddata->irq = platform_get_irq(pdev, 0);
1080 platform_set_drvdata(pdev, intelmaddata);
1081 intelmaddata->card = card;
1082 intelmaddata->card_id = card_id;
1083 intelmaddata->card_index = card_index;
1084 intelmaddata->master_mute = UNMUTE;
1085 intelmaddata->playback_cnt = intelmaddata->capture_cnt = 0;
1086 strncpy(card->driver, INTEL_MAD, strlen(INTEL_MAD));
1087 strncpy(card->shortname, INTEL_MAD, strlen(INTEL_MAD));
1088
1089 intelmaddata->sstdrv_ops->module_name = SST_CARD_NAMES;
1090 /* registering with LPE driver to get access to SST APIs to use */
1091 ret_val = snd_intelmad_sst_register(intelmaddata);
1092 if (ret_val) {
1093 pr_err("snd_intelmad_sst_register failed\n");
1094 goto free_allocs;
1095 }
1096
1097 intelmaddata->pmic_status = PMIC_INIT;
1098
1099 ret_val = snd_intelmad_pcm(card, intelmaddata);
1100 if (ret_val) {
1101 pr_err("snd_intelmad_pcm failed\n");
1102 goto free_allocs;
1103 }
1104
1105 ret_val = snd_intelmad_mixer(intelmaddata);
1106 if (ret_val) {
1107 pr_err("snd_intelmad_mixer failed\n");
1108 goto free_allocs;
1109 }
1110
1111 ret_val = snd_intelmad_jack(intelmaddata);
1112 if (ret_val) {
1113 pr_err("snd_intelmad_jack failed\n");
1114 goto free_allocs;
1115 }
1116
1117 /*create work queue for jack interrupt*/
1118 INIT_WORK(&intelmaddata->mad_jack_msg.wq,
1119 sst_process_mad_jack_detection);
1120
1121 intelmaddata->mad_jack_wq = create_workqueue("sst_mad_jack_wq");
1122 if (!intelmaddata->mad_jack_wq)
1123 goto free_mad_jack_wq;
1124
1125 ret_val = snd_intelmad_register_irq(intelmaddata);
1126 if (ret_val) {
1127 pr_err("snd_intelmad_register_irq fail\n");
1128 goto free_allocs;
1129 }
1130
1131 /* internal function call to register device with ALSA */
1132 ret_val = snd_intelmad_create(intelmaddata, card);
1133 if (ret_val) {
1134 pr_err("snd_intelmad_create failed\n");
1135 goto free_allocs;
1136 }
1137 card->private_data = &intelmaddata;
1138 snd_card_set_dev(card, &pdev->dev);
1139 ret_val = snd_card_register(card);
1140 if (ret_val) {
1141 pr_err("snd_card_register failed\n");
1142 goto free_allocs;
1143 }
1144
1145 pr_debug("snd_intelmad_probe complete\n");
1146 return ret_val;
1147
1148 free_mad_jack_wq:
1149 destroy_workqueue(intelmaddata->mad_jack_wq);
1150 free_allocs:
1151 pr_err("probe failed\n");
1152 snd_card_free(card);
1153 kfree(intelmaddata->sstdrv_ops);
1154 kfree(intelmaddata);
1155 return ret_val;
1156 }
1157
1158
1159 static int snd_intelmad_remove(struct platform_device *pdev)
1160 {
1161 struct snd_intelmad *intelmaddata = platform_get_drvdata(pdev);
1162
1163 if (intelmaddata) {
1164 snd_card_free(intelmaddata->card);
1165 unregister_sst_card(intelmaddata->sstdrv_ops);
1166 /* free allocated memory for internal context */
1167 destroy_workqueue(intelmaddata->mad_jack_wq);
1168 kfree(intelmaddata->sstdrv_ops);
1169 kfree(intelmaddata);
1170 }
1171 return 0;
1172 }
1173
1174 /*********************************************************************
1175 * Driver initialization and exit
1176 *********************************************************************/
1177 static const struct platform_device_id snd_intelmad_ids[] = {
1178 {DRIVER_NAME_MRST, CPU_CHIP_LINCROFT},
1179 {DRIVER_NAME_MFLD, CPU_CHIP_PENWELL},
1180 {"", 0},
1181
1182 };
1183
1184 static struct platform_driver snd_intelmad_driver = {
1185 .driver = {
1186 .owner = THIS_MODULE,
1187 .name = "intel_mid_sound_card",
1188 },
1189 .id_table = snd_intelmad_ids,
1190 .probe = snd_intelmad_probe,
1191 .remove = __devexit_p(snd_intelmad_remove),
1192 };
1193
1194 /*
1195 * alsa_card_intelmad_init- driver init function
1196 *
1197 * This function is called when driver module is inserted
1198 */
1199 static int __init alsa_card_intelmad_init(void)
1200 {
1201 pr_debug("mad_init called\n");
1202 return platform_driver_register(&snd_intelmad_driver);
1203 }
1204
1205 /**
1206 * alsa_card_intelmad_exit- driver exit function
1207 *
1208 * This function is called when driver module is removed
1209 */
1210 static void __exit alsa_card_intelmad_exit(void)
1211 {
1212 pr_debug("mad_exit called\n");
1213 return platform_driver_unregister(&snd_intelmad_driver);
1214 }
1215
1216 module_init(alsa_card_intelmad_init)
1217 module_exit(alsa_card_intelmad_exit)
1218
ubuntu-bionic-kernel mirror