dmtimer.c 19.3 KB
Newer Older
1 2 3 4 5
/*
 * linux/arch/arm/plat-omap/dmtimer.c
 *
 * OMAP Dual-Mode Timers
 *
6 7 8 9 10 11
 * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com/
 * Tarun Kanti DebBarma <tarun.kanti@ti.com>
 * Thara Gopinath <thara@ti.com>
 *
 * dmtimer adaptation to platform_driver.
 *
12
 * Copyright (C) 2005 Nokia Corporation
13 14
 * OMAP2 support by Juha Yrjola
 * API improvements and OMAP2 clock framework support by Timo Teras
15
 *
16 17 18
 * Copyright (C) 2009 Texas Instruments
 * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
 *
19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
 * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * You should have received a copy of the  GNU General Public License along
 * with this program; if not, write  to the Free Software Foundation, Inc.,
 * 675 Mass Ave, Cambridge, MA 02139, USA.
 */

38
#include <linux/module.h>
39
#include <linux/io.h>
40
#include <linux/slab.h>
41
#include <linux/err.h>
42
#include <linux/pm_runtime.h>
43

44
#include <plat/dmtimer.h>
45

46 47
#include <mach/hardware.h>

48
static u32 omap_reserved_systimers;
49
static LIST_HEAD(omap_timer_list);
50
static DEFINE_SPINLOCK(dm_timer_lock);
51

52 53 54 55 56 57 58 59
/**
 * omap_dm_timer_read_reg - read timer registers in posted and non-posted mode
 * @timer:      timer pointer over which read operation to perform
 * @reg:        lowest byte holds the register offset
 *
 * The posted mode bit is encoded in reg. Note that in posted mode write
 * pending bit must be checked. Otherwise a read of a non completed write
 * will produce an error.
60 61
 */
static inline u32 omap_dm_timer_read_reg(struct omap_dm_timer *timer, u32 reg)
62
{
63 64
	WARN_ON((reg & 0xff) < _OMAP_TIMER_WAKEUP_EN_OFFSET);
	return __omap_dm_timer_read(timer, reg, timer->posted);
65
}
66

67 68 69 70 71 72 73 74 75
/**
 * omap_dm_timer_write_reg - write timer registers in posted and non-posted mode
 * @timer:      timer pointer over which write operation is to perform
 * @reg:        lowest byte holds the register offset
 * @value:      data to write into the register
 *
 * The posted mode bit is encoded in reg. Note that in posted mode the write
 * pending bit must be checked. Otherwise a write on a register which has a
 * pending write will be lost.
76 77 78
 */
static void omap_dm_timer_write_reg(struct omap_dm_timer *timer, u32 reg,
						u32 value)
79
{
80 81
	WARN_ON((reg & 0xff) < _OMAP_TIMER_WAKEUP_EN_OFFSET);
	__omap_dm_timer_write(timer, reg, value, timer->posted);
82 83
}

84 85
static void omap_timer_restore_context(struct omap_dm_timer *timer)
{
86
	if (timer->revision == 1)
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
		__raw_writel(timer->context.tistat, timer->sys_stat);

	__raw_writel(timer->context.tisr, timer->irq_stat);
	omap_dm_timer_write_reg(timer, OMAP_TIMER_WAKEUP_EN_REG,
				timer->context.twer);
	omap_dm_timer_write_reg(timer, OMAP_TIMER_COUNTER_REG,
				timer->context.tcrr);
	omap_dm_timer_write_reg(timer, OMAP_TIMER_LOAD_REG,
				timer->context.tldr);
	omap_dm_timer_write_reg(timer, OMAP_TIMER_MATCH_REG,
				timer->context.tmar);
	omap_dm_timer_write_reg(timer, OMAP_TIMER_IF_CTRL_REG,
				timer->context.tsicr);
	__raw_writel(timer->context.tier, timer->irq_ena);
	omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG,
				timer->context.tclr);
}

105
static void omap_dm_timer_wait_for_reset(struct omap_dm_timer *timer)
106
{
107 108
	int c;

109 110 111
	if (!timer->sys_stat)
		return;

112
	c = 0;
113
	while (!(__raw_readl(timer->sys_stat) & 1)) {
114 115 116 117 118 119
		c++;
		if (c > 100000) {
			printk(KERN_ERR "Timer failed to reset\n");
			return;
		}
	}
120 121
}

122 123
static void omap_dm_timer_reset(struct omap_dm_timer *timer)
{
124
	omap_dm_timer_enable(timer);
125
	if (timer->pdev->id != 1) {
126 127 128
		omap_dm_timer_write_reg(timer, OMAP_TIMER_IF_CTRL_REG, 0x06);
		omap_dm_timer_wait_for_reset(timer);
	}
129

130
	__omap_dm_timer_reset(timer, 0, 0);
131
	omap_dm_timer_disable(timer);
132
	timer->posted = 1;
133 134
}

135
int omap_dm_timer_prepare(struct omap_dm_timer *timer)
136
{
137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
	struct dmtimer_platform_data *pdata = timer->pdev->dev.platform_data;
	int ret;

	timer->fclk = clk_get(&timer->pdev->dev, "fck");
	if (WARN_ON_ONCE(IS_ERR_OR_NULL(timer->fclk))) {
		timer->fclk = NULL;
		dev_err(&timer->pdev->dev, ": No fclk handle.\n");
		return -EINVAL;
	}

	if (pdata->needs_manual_reset)
		omap_dm_timer_reset(timer);

	ret = omap_dm_timer_set_source(timer, OMAP_TIMER_SRC_32_KHZ);

	timer->posted = 1;
	return ret;
154 155
}

156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
static inline u32 omap_dm_timer_reserved_systimer(int id)
{
	return (omap_reserved_systimers & (1 << (id - 1))) ? 1 : 0;
}

int omap_dm_timer_reserve_systimer(int id)
{
	if (omap_dm_timer_reserved_systimer(id))
		return -ENODEV;

	omap_reserved_systimers |= (1 << (id - 1));

	return 0;
}

171 172
struct omap_dm_timer *omap_dm_timer_request(void)
{
173
	struct omap_dm_timer *timer = NULL, *t;
174
	unsigned long flags;
175
	int ret = 0;
176 177

	spin_lock_irqsave(&dm_timer_lock, flags);
178 179
	list_for_each_entry(t, &omap_timer_list, node) {
		if (t->reserved)
180 181
			continue;

182
		timer = t;
T
Timo Teras 已提交
183
		timer->reserved = 1;
184 185
		break;
	}
186 187 188 189 190 191 192 193

	if (timer) {
		ret = omap_dm_timer_prepare(timer);
		if (ret) {
			timer->reserved = 0;
			timer = NULL;
		}
	}
194 195
	spin_unlock_irqrestore(&dm_timer_lock, flags);

196 197
	if (!timer)
		pr_debug("%s: timer request failed!\n", __func__);
T
Timo Teras 已提交
198

199 200
	return timer;
}
201
EXPORT_SYMBOL_GPL(omap_dm_timer_request);
202 203

struct omap_dm_timer *omap_dm_timer_request_specific(int id)
204
{
205
	struct omap_dm_timer *timer = NULL, *t;
206
	unsigned long flags;
207
	int ret = 0;
208

209
	spin_lock_irqsave(&dm_timer_lock, flags);
210 211 212 213 214 215
	list_for_each_entry(t, &omap_timer_list, node) {
		if (t->pdev->id == id && !t->reserved) {
			timer = t;
			timer->reserved = 1;
			break;
		}
216
	}
217

218 219 220 221 222 223 224
	if (timer) {
		ret = omap_dm_timer_prepare(timer);
		if (ret) {
			timer->reserved = 0;
			timer = NULL;
		}
	}
225 226
	spin_unlock_irqrestore(&dm_timer_lock, flags);

227 228
	if (!timer)
		pr_debug("%s: timer%d request failed!\n", __func__, id);
T
Timo Teras 已提交
229

230
	return timer;
231
}
232
EXPORT_SYMBOL_GPL(omap_dm_timer_request_specific);
233

234
int omap_dm_timer_free(struct omap_dm_timer *timer)
235
{
236 237 238
	if (unlikely(!timer))
		return -EINVAL;

239
	clk_put(timer->fclk);
240

241 242
	WARN_ON(!timer->reserved);
	timer->reserved = 0;
243
	return 0;
244
}
245
EXPORT_SYMBOL_GPL(omap_dm_timer_free);
246

247 248
void omap_dm_timer_enable(struct omap_dm_timer *timer)
{
249
	pm_runtime_get_sync(&timer->pdev->dev);
250
}
251
EXPORT_SYMBOL_GPL(omap_dm_timer_enable);
252 253 254

void omap_dm_timer_disable(struct omap_dm_timer *timer)
{
255
	pm_runtime_put(&timer->pdev->dev);
256
}
257
EXPORT_SYMBOL_GPL(omap_dm_timer_disable);
258

259 260
int omap_dm_timer_get_irq(struct omap_dm_timer *timer)
{
261 262 263
	if (timer)
		return timer->irq;
	return -EINVAL;
264
}
265
EXPORT_SYMBOL_GPL(omap_dm_timer_get_irq);
266 267 268

#if defined(CONFIG_ARCH_OMAP1)

269 270 271 272 273 274
/**
 * omap_dm_timer_modify_idlect_mask - Check if any running timers use ARMXOR
 * @inputmask: current value of idlect mask
 */
__u32 omap_dm_timer_modify_idlect_mask(__u32 inputmask)
{
275 276 277
	int i = 0;
	struct omap_dm_timer *timer = NULL;
	unsigned long flags;
278 279 280 281 282 283

	/* If ARMXOR cannot be idled this function call is unnecessary */
	if (!(inputmask & (1 << 1)))
		return inputmask;

	/* If any active timer is using ARMXOR return modified mask */
284 285
	spin_lock_irqsave(&dm_timer_lock, flags);
	list_for_each_entry(timer, &omap_timer_list, node) {
286 287
		u32 l;

288
		l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
289 290
		if (l & OMAP_TIMER_CTRL_ST) {
			if (((omap_readl(MOD_CONF_CTRL_1) >> (i * 2)) & 0x03) == 0)
291 292 293 294
				inputmask &= ~(1 << 1);
			else
				inputmask &= ~(1 << 2);
		}
295
		i++;
296
	}
297
	spin_unlock_irqrestore(&dm_timer_lock, flags);
298 299 300

	return inputmask;
}
301
EXPORT_SYMBOL_GPL(omap_dm_timer_modify_idlect_mask);
302

303
#else
304

305
struct clk *omap_dm_timer_get_fclk(struct omap_dm_timer *timer)
306
{
307 308 309
	if (timer)
		return timer->fclk;
	return NULL;
310
}
311
EXPORT_SYMBOL_GPL(omap_dm_timer_get_fclk);
312

313 314 315
__u32 omap_dm_timer_modify_idlect_mask(__u32 inputmask)
{
	BUG();
316 317

	return 0;
318
}
319
EXPORT_SYMBOL_GPL(omap_dm_timer_modify_idlect_mask);
320

321
#endif
322

323
int omap_dm_timer_trigger(struct omap_dm_timer *timer)
324
{
325 326 327
	if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev))) {
		pr_err("%s: timer not available or enabled.\n", __func__);
		return -EINVAL;
328 329
	}

330
	omap_dm_timer_write_reg(timer, OMAP_TIMER_TRIGGER_REG, 0);
331
	return 0;
332
}
333
EXPORT_SYMBOL_GPL(omap_dm_timer_trigger);
334

335
int omap_dm_timer_start(struct omap_dm_timer *timer)
336 337
{
	u32 l;
338

339 340 341
	if (unlikely(!timer))
		return -EINVAL;

342 343
	omap_dm_timer_enable(timer);

344
	if (!(timer->capability & OMAP_TIMER_ALWON)) {
345 346 347 348 349 350
		u32 ctx_loss_cnt_after =
			timer->get_context_loss_count(&timer->pdev->dev);
		if (ctx_loss_cnt_after != timer->ctx_loss_count)
			omap_timer_restore_context(timer);
	}

351 352 353 354 355
	l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
	if (!(l & OMAP_TIMER_CTRL_ST)) {
		l |= OMAP_TIMER_CTRL_ST;
		omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
	}
356 357 358

	/* Save the context */
	timer->context.tclr = l;
359
	return 0;
360
}
361
EXPORT_SYMBOL_GPL(omap_dm_timer_start);
362

363
int omap_dm_timer_stop(struct omap_dm_timer *timer)
364
{
365
	unsigned long rate = 0;
366
	struct dmtimer_platform_data *pdata;
367

368 369 370
	if (unlikely(!timer))
		return -EINVAL;

371
	pdata = timer->pdev->dev.platform_data;
372 373
	if (!pdata->needs_manual_reset)
		rate = clk_get_rate(timer->fclk);
374

375
	__omap_dm_timer_stop(timer, timer->posted, rate);
376

377 378
	if (!(timer->capability & OMAP_TIMER_ALWON) &&
			timer->get_context_loss_count)
379 380 381 382 383 384 385 386 387 388 389 390
		timer->ctx_loss_count =
			timer->get_context_loss_count(&timer->pdev->dev);

	/*
	 * Since the register values are computed and written within
	 * __omap_dm_timer_stop, we need to use read to retrieve the
	 * context.
	 */
	timer->context.tclr =
			omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
	timer->context.tisr = __raw_readl(timer->irq_stat);
	omap_dm_timer_disable(timer);
391
	return 0;
392
}
393
EXPORT_SYMBOL_GPL(omap_dm_timer_stop);
394

395
int omap_dm_timer_set_source(struct omap_dm_timer *timer, int source)
396
{
397
	int ret;
398 399 400 401 402 403
	struct dmtimer_platform_data *pdata;

	if (unlikely(!timer))
		return -EINVAL;

	pdata = timer->pdev->dev.platform_data;
404

405
	if (source < 0 || source >= 3)
406
		return -EINVAL;
407

408 409 410
	ret = pdata->set_timer_src(timer->pdev, source);

	return ret;
411
}
412
EXPORT_SYMBOL_GPL(omap_dm_timer_set_source);
413

414
int omap_dm_timer_set_load(struct omap_dm_timer *timer, int autoreload,
415
			    unsigned int load)
416 417
{
	u32 l;
418

419 420 421
	if (unlikely(!timer))
		return -EINVAL;

422
	omap_dm_timer_enable(timer);
423
	l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
424 425 426 427
	if (autoreload)
		l |= OMAP_TIMER_CTRL_AR;
	else
		l &= ~OMAP_TIMER_CTRL_AR;
428
	omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
429
	omap_dm_timer_write_reg(timer, OMAP_TIMER_LOAD_REG, load);
430

431
	omap_dm_timer_write_reg(timer, OMAP_TIMER_TRIGGER_REG, 0);
432 433 434 435
	/* Save the context */
	timer->context.tclr = l;
	timer->context.tldr = load;
	omap_dm_timer_disable(timer);
436
	return 0;
437
}
438
EXPORT_SYMBOL_GPL(omap_dm_timer_set_load);
439

440
/* Optimized set_load which removes costly spin wait in timer_start */
441
int omap_dm_timer_set_load_start(struct omap_dm_timer *timer, int autoreload,
442 443 444 445
                            unsigned int load)
{
	u32 l;

446 447 448
	if (unlikely(!timer))
		return -EINVAL;

449 450
	omap_dm_timer_enable(timer);

451
	if (!(timer->capability & OMAP_TIMER_ALWON)) {
452 453 454 455 456 457
		u32 ctx_loss_cnt_after =
			timer->get_context_loss_count(&timer->pdev->dev);
		if (ctx_loss_cnt_after != timer->ctx_loss_count)
			omap_timer_restore_context(timer);
	}

458
	l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
459
	if (autoreload) {
460
		l |= OMAP_TIMER_CTRL_AR;
461 462
		omap_dm_timer_write_reg(timer, OMAP_TIMER_LOAD_REG, load);
	} else {
463
		l &= ~OMAP_TIMER_CTRL_AR;
464
	}
465 466
	l |= OMAP_TIMER_CTRL_ST;

467
	__omap_dm_timer_load_start(timer, l, load, timer->posted);
468 469 470 471 472

	/* Save the context */
	timer->context.tclr = l;
	timer->context.tldr = load;
	timer->context.tcrr = load;
473
	return 0;
474
}
475
EXPORT_SYMBOL_GPL(omap_dm_timer_set_load_start);
476

477
int omap_dm_timer_set_match(struct omap_dm_timer *timer, int enable,
478
			     unsigned int match)
479 480 481
{
	u32 l;

482 483 484
	if (unlikely(!timer))
		return -EINVAL;

485
	omap_dm_timer_enable(timer);
486
	l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
T
Timo Teras 已提交
487
	if (enable)
488 489 490
		l |= OMAP_TIMER_CTRL_CE;
	else
		l &= ~OMAP_TIMER_CTRL_CE;
491
	omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
492
	omap_dm_timer_write_reg(timer, OMAP_TIMER_MATCH_REG, match);
493 494 495 496 497

	/* Save the context */
	timer->context.tclr = l;
	timer->context.tmar = match;
	omap_dm_timer_disable(timer);
498
	return 0;
499
}
500
EXPORT_SYMBOL_GPL(omap_dm_timer_set_match);
501

502
int omap_dm_timer_set_pwm(struct omap_dm_timer *timer, int def_on,
503
			   int toggle, int trigger)
504 505 506
{
	u32 l;

507 508 509
	if (unlikely(!timer))
		return -EINVAL;

510
	omap_dm_timer_enable(timer);
511
	l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
512 513 514 515 516 517 518
	l &= ~(OMAP_TIMER_CTRL_GPOCFG | OMAP_TIMER_CTRL_SCPWM |
	       OMAP_TIMER_CTRL_PT | (0x03 << 10));
	if (def_on)
		l |= OMAP_TIMER_CTRL_SCPWM;
	if (toggle)
		l |= OMAP_TIMER_CTRL_PT;
	l |= trigger << 10;
519
	omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
520 521 522 523

	/* Save the context */
	timer->context.tclr = l;
	omap_dm_timer_disable(timer);
524
	return 0;
525
}
526
EXPORT_SYMBOL_GPL(omap_dm_timer_set_pwm);
527

528
int omap_dm_timer_set_prescaler(struct omap_dm_timer *timer, int prescaler)
529 530 531
{
	u32 l;

532 533 534
	if (unlikely(!timer))
		return -EINVAL;

535
	omap_dm_timer_enable(timer);
536
	l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
537 538 539 540 541
	l &= ~(OMAP_TIMER_CTRL_PRE | (0x07 << 2));
	if (prescaler >= 0x00 && prescaler <= 0x07) {
		l |= OMAP_TIMER_CTRL_PRE;
		l |= prescaler << 2;
	}
542
	omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
543 544 545 546

	/* Save the context */
	timer->context.tclr = l;
	omap_dm_timer_disable(timer);
547
	return 0;
548
}
549
EXPORT_SYMBOL_GPL(omap_dm_timer_set_prescaler);
550

551
int omap_dm_timer_set_int_enable(struct omap_dm_timer *timer,
552
				  unsigned int value)
553
{
554 555 556
	if (unlikely(!timer))
		return -EINVAL;

557
	omap_dm_timer_enable(timer);
558
	__omap_dm_timer_int_enable(timer, value);
559 560 561 562 563

	/* Save the context */
	timer->context.tier = value;
	timer->context.twer = value;
	omap_dm_timer_disable(timer);
564
	return 0;
565
}
566
EXPORT_SYMBOL_GPL(omap_dm_timer_set_int_enable);
567

568
unsigned int omap_dm_timer_read_status(struct omap_dm_timer *timer)
569
{
570 571
	unsigned int l;

572 573
	if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev))) {
		pr_err("%s: timer not available or enabled.\n", __func__);
574 575 576
		return 0;
	}

577
	l = __raw_readl(timer->irq_stat);
578 579

	return l;
580
}
581
EXPORT_SYMBOL_GPL(omap_dm_timer_read_status);
582

583
int omap_dm_timer_write_status(struct omap_dm_timer *timer, unsigned int value)
584
{
585 586 587
	if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev)))
		return -EINVAL;

588
	__omap_dm_timer_write_status(timer, value);
589 590
	/* Save the context */
	timer->context.tisr = value;
591
	return 0;
592
}
593
EXPORT_SYMBOL_GPL(omap_dm_timer_write_status);
594

595
unsigned int omap_dm_timer_read_counter(struct omap_dm_timer *timer)
596
{
597 598
	if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev))) {
		pr_err("%s: timer not iavailable or enabled.\n", __func__);
599 600 601
		return 0;
	}

602
	return __omap_dm_timer_read_counter(timer, timer->posted);
603
}
604
EXPORT_SYMBOL_GPL(omap_dm_timer_read_counter);
605

606
int omap_dm_timer_write_counter(struct omap_dm_timer *timer, unsigned int value)
T
Timo Teras 已提交
607
{
608 609 610
	if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev))) {
		pr_err("%s: timer not available or enabled.\n", __func__);
		return -EINVAL;
611 612
	}

613
	omap_dm_timer_write_reg(timer, OMAP_TIMER_COUNTER_REG, value);
614 615 616

	/* Save the context */
	timer->context.tcrr = value;
617
	return 0;
T
Timo Teras 已提交
618
}
619
EXPORT_SYMBOL_GPL(omap_dm_timer_write_counter);
T
Timo Teras 已提交
620

621
int omap_dm_timers_active(void)
622
{
623
	struct omap_dm_timer *timer;
624

625
	list_for_each_entry(timer, &omap_timer_list, node) {
626
		if (!timer->reserved)
627 628
			continue;

629
		if (omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG) &
630
		    OMAP_TIMER_CTRL_ST) {
631
			return 1;
632
		}
633 634 635
	}
	return 0;
}
636
EXPORT_SYMBOL_GPL(omap_dm_timers_active);
637

638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693
/**
 * omap_dm_timer_probe - probe function called for every registered device
 * @pdev:	pointer to current timer platform device
 *
 * Called by driver framework at the end of device registration for all
 * timer devices.
 */
static int __devinit omap_dm_timer_probe(struct platform_device *pdev)
{
	int ret;
	unsigned long flags;
	struct omap_dm_timer *timer;
	struct resource *mem, *irq, *ioarea;
	struct dmtimer_platform_data *pdata = pdev->dev.platform_data;

	if (!pdata) {
		dev_err(&pdev->dev, "%s: no platform data.\n", __func__);
		return -ENODEV;
	}

	irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (unlikely(!irq)) {
		dev_err(&pdev->dev, "%s: no IRQ resource.\n", __func__);
		return -ENODEV;
	}

	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (unlikely(!mem)) {
		dev_err(&pdev->dev, "%s: no memory resource.\n", __func__);
		return -ENODEV;
	}

	ioarea = request_mem_region(mem->start, resource_size(mem),
			pdev->name);
	if (!ioarea) {
		dev_err(&pdev->dev, "%s: region already claimed.\n", __func__);
		return -EBUSY;
	}

	timer = kzalloc(sizeof(struct omap_dm_timer), GFP_KERNEL);
	if (!timer) {
		dev_err(&pdev->dev, "%s: no memory for omap_dm_timer.\n",
			__func__);
		ret = -ENOMEM;
		goto err_free_ioregion;
	}

	timer->io_base = ioremap(mem->start, resource_size(mem));
	if (!timer->io_base) {
		dev_err(&pdev->dev, "%s: ioremap failed.\n", __func__);
		ret = -ENOMEM;
		goto err_free_mem;
	}

	timer->id = pdev->id;
	timer->irq = irq->start;
694
	timer->reserved = omap_dm_timer_reserved_systimer(timer->id);
695
	timer->pdev = pdev;
696
	timer->get_context_loss_count = pdata->get_context_loss_count;
697
	timer->capability = pdata->timer_capability;
698

699 700 701 702 703 704
	/* Skip pm_runtime_enable for OMAP1 */
	if (!pdata->needs_manual_reset) {
		pm_runtime_enable(&pdev->dev);
		pm_runtime_irq_safe(&pdev->dev);
	}

705 706 707 708 709 710
	if (!timer->reserved) {
		pm_runtime_get_sync(&pdev->dev);
		__omap_dm_timer_init_regs(timer);
		pm_runtime_put(&pdev->dev);
	}

711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757
	/* add the timer element to the list */
	spin_lock_irqsave(&dm_timer_lock, flags);
	list_add_tail(&timer->node, &omap_timer_list);
	spin_unlock_irqrestore(&dm_timer_lock, flags);

	dev_dbg(&pdev->dev, "Device Probed.\n");

	return 0;

err_free_mem:
	kfree(timer);

err_free_ioregion:
	release_mem_region(mem->start, resource_size(mem));

	return ret;
}

/**
 * omap_dm_timer_remove - cleanup a registered timer device
 * @pdev:	pointer to current timer platform device
 *
 * Called by driver framework whenever a timer device is unregistered.
 * In addition to freeing platform resources it also deletes the timer
 * entry from the local list.
 */
static int __devexit omap_dm_timer_remove(struct platform_device *pdev)
{
	struct omap_dm_timer *timer;
	unsigned long flags;
	int ret = -EINVAL;

	spin_lock_irqsave(&dm_timer_lock, flags);
	list_for_each_entry(timer, &omap_timer_list, node)
		if (timer->pdev->id == pdev->id) {
			list_del(&timer->node);
			kfree(timer);
			ret = 0;
			break;
		}
	spin_unlock_irqrestore(&dm_timer_lock, flags);

	return ret;
}

static struct platform_driver omap_dm_timer_driver = {
	.probe  = omap_dm_timer_probe,
758
	.remove = __devexit_p(omap_dm_timer_remove),
759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
	.driver = {
		.name   = "omap_timer",
	},
};

static int __init omap_dm_timer_driver_init(void)
{
	return platform_driver_register(&omap_dm_timer_driver);
}

static void __exit omap_dm_timer_driver_exit(void)
{
	platform_driver_unregister(&omap_dm_timer_driver);
}

early_platform_init("earlytimer", &omap_dm_timer_driver);
module_init(omap_dm_timer_driver_init);
module_exit(omap_dm_timer_driver_exit);

MODULE_DESCRIPTION("OMAP Dual-Mode Timer Driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:" DRIVER_NAME);
MODULE_AUTHOR("Texas Instruments Inc");