dmtimer.c 19.8 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/device.h>
41
#include <linux/err.h>
42
#include <linux/pm_runtime.h>
43

44
#include <plat/dmtimer.h>
45
#include <plat/omap-pm.h>
46

47 48
#include <mach/hardware.h>

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

53 54 55 56 57 58 59 60
/**
 * 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.
61 62
 */
static inline u32 omap_dm_timer_read_reg(struct omap_dm_timer *timer, u32 reg)
63
{
64 65
	WARN_ON((reg & 0xff) < _OMAP_TIMER_WAKEUP_EN_OFFSET);
	return __omap_dm_timer_read(timer, reg, timer->posted);
66
}
67

68 69 70 71 72 73 74 75 76
/**
 * 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.
77 78 79
 */
static void omap_dm_timer_write_reg(struct omap_dm_timer *timer, u32 reg,
						u32 value)
80
{
81 82
	WARN_ON((reg & 0xff) < _OMAP_TIMER_WAKEUP_EN_OFFSET);
	__omap_dm_timer_write(timer, reg, value, timer->posted);
83 84
}

85 86
static void omap_timer_restore_context(struct omap_dm_timer *timer)
{
87
	if (timer->revision == 1)
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
		__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);
}

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

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

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

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

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

136
int omap_dm_timer_prepare(struct omap_dm_timer *timer)
137
{
138 139
	int ret;

J
Jon Hunter 已提交
140 141 142 143 144 145 146 147 148 149 150
	/*
	 * FIXME: OMAP1 devices do not use the clock framework for dmtimers so
	 * do not call clk_get() for these devices.
	 */
	if (!(timer->capability & OMAP_TIMER_NEEDS_RESET)) {
		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;
		}
151 152
	}

153
	if (timer->capability & OMAP_TIMER_NEEDS_RESET)
154 155 156 157 158 159
		omap_dm_timer_reset(timer);

	ret = omap_dm_timer_set_source(timer, OMAP_TIMER_SRC_32_KHZ);

	timer->posted = 1;
	return ret;
160 161
}

162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
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;
}

177 178
struct omap_dm_timer *omap_dm_timer_request(void)
{
179
	struct omap_dm_timer *timer = NULL, *t;
180
	unsigned long flags;
181
	int ret = 0;
182 183

	spin_lock_irqsave(&dm_timer_lock, flags);
184 185
	list_for_each_entry(t, &omap_timer_list, node) {
		if (t->reserved)
186 187
			continue;

188
		timer = t;
T
Timo Teras 已提交
189
		timer->reserved = 1;
190 191
		break;
	}
192
	spin_unlock_irqrestore(&dm_timer_lock, flags);
193 194 195 196 197 198 199 200

	if (timer) {
		ret = omap_dm_timer_prepare(timer);
		if (ret) {
			timer->reserved = 0;
			timer = NULL;
		}
	}
201

202 203
	if (!timer)
		pr_debug("%s: timer request failed!\n", __func__);
T
Timo Teras 已提交
204

205 206
	return timer;
}
207
EXPORT_SYMBOL_GPL(omap_dm_timer_request);
208 209

struct omap_dm_timer *omap_dm_timer_request_specific(int id)
210
{
211
	struct omap_dm_timer *timer = NULL, *t;
212
	unsigned long flags;
213
	int ret = 0;
214

215
	spin_lock_irqsave(&dm_timer_lock, flags);
216 217 218 219 220 221
	list_for_each_entry(t, &omap_timer_list, node) {
		if (t->pdev->id == id && !t->reserved) {
			timer = t;
			timer->reserved = 1;
			break;
		}
222
	}
223
	spin_unlock_irqrestore(&dm_timer_lock, flags);
224

225 226 227 228 229 230 231
	if (timer) {
		ret = omap_dm_timer_prepare(timer);
		if (ret) {
			timer->reserved = 0;
			timer = NULL;
		}
	}
232

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

236
	return timer;
237
}
238
EXPORT_SYMBOL_GPL(omap_dm_timer_request_specific);
239

240
int omap_dm_timer_free(struct omap_dm_timer *timer)
241
{
242 243 244
	if (unlikely(!timer))
		return -EINVAL;

245
	clk_put(timer->fclk);
246

247 248
	WARN_ON(!timer->reserved);
	timer->reserved = 0;
249
	return 0;
250
}
251
EXPORT_SYMBOL_GPL(omap_dm_timer_free);
252

253 254
void omap_dm_timer_enable(struct omap_dm_timer *timer)
{
255
	pm_runtime_get_sync(&timer->pdev->dev);
256
}
257
EXPORT_SYMBOL_GPL(omap_dm_timer_enable);
258 259 260

void omap_dm_timer_disable(struct omap_dm_timer *timer)
{
261
	pm_runtime_put_sync(&timer->pdev->dev);
262
}
263
EXPORT_SYMBOL_GPL(omap_dm_timer_disable);
264

265 266
int omap_dm_timer_get_irq(struct omap_dm_timer *timer)
{
267 268 269
	if (timer)
		return timer->irq;
	return -EINVAL;
270
}
271
EXPORT_SYMBOL_GPL(omap_dm_timer_get_irq);
272 273 274

#if defined(CONFIG_ARCH_OMAP1)

275 276 277 278 279 280
/**
 * 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)
{
281 282 283
	int i = 0;
	struct omap_dm_timer *timer = NULL;
	unsigned long flags;
284 285 286 287 288 289

	/* 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 */
290 291
	spin_lock_irqsave(&dm_timer_lock, flags);
	list_for_each_entry(timer, &omap_timer_list, node) {
292 293
		u32 l;

294
		l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
295 296
		if (l & OMAP_TIMER_CTRL_ST) {
			if (((omap_readl(MOD_CONF_CTRL_1) >> (i * 2)) & 0x03) == 0)
297 298 299 300
				inputmask &= ~(1 << 1);
			else
				inputmask &= ~(1 << 2);
		}
301
		i++;
302
	}
303
	spin_unlock_irqrestore(&dm_timer_lock, flags);
304 305 306

	return inputmask;
}
307
EXPORT_SYMBOL_GPL(omap_dm_timer_modify_idlect_mask);
308

309
#else
310

311
struct clk *omap_dm_timer_get_fclk(struct omap_dm_timer *timer)
312
{
313 314 315
	if (timer)
		return timer->fclk;
	return NULL;
316
}
317
EXPORT_SYMBOL_GPL(omap_dm_timer_get_fclk);
318

319 320 321
__u32 omap_dm_timer_modify_idlect_mask(__u32 inputmask)
{
	BUG();
322 323

	return 0;
324
}
325
EXPORT_SYMBOL_GPL(omap_dm_timer_modify_idlect_mask);
326

327
#endif
328

329
int omap_dm_timer_trigger(struct omap_dm_timer *timer)
330
{
331 332 333
	if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev))) {
		pr_err("%s: timer not available or enabled.\n", __func__);
		return -EINVAL;
334 335
	}

336
	omap_dm_timer_write_reg(timer, OMAP_TIMER_TRIGGER_REG, 0);
337
	return 0;
338
}
339
EXPORT_SYMBOL_GPL(omap_dm_timer_trigger);
340

341
int omap_dm_timer_start(struct omap_dm_timer *timer)
342 343
{
	u32 l;
344

345 346 347
	if (unlikely(!timer))
		return -EINVAL;

348 349
	omap_dm_timer_enable(timer);

350
	if (!(timer->capability & OMAP_TIMER_ALWON)) {
351 352
		if (omap_pm_get_dev_context_loss_count(&timer->pdev->dev) !=
				timer->ctx_loss_count)
353 354 355
			omap_timer_restore_context(timer);
	}

356 357 358 359 360
	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);
	}
361 362 363

	/* Save the context */
	timer->context.tclr = l;
364
	return 0;
365
}
366
EXPORT_SYMBOL_GPL(omap_dm_timer_start);
367

368
int omap_dm_timer_stop(struct omap_dm_timer *timer)
369
{
370
	unsigned long rate = 0;
371

372 373 374
	if (unlikely(!timer))
		return -EINVAL;

375
	if (!(timer->capability & OMAP_TIMER_NEEDS_RESET))
376
		rate = clk_get_rate(timer->fclk);
377

378
	__omap_dm_timer_stop(timer, timer->posted, rate);
379

380
	if (!(timer->capability & OMAP_TIMER_ALWON))
381
		timer->ctx_loss_count =
382
			omap_pm_get_dev_context_loss_count(&timer->pdev->dev);
383 384 385 386 387 388 389 390 391 392

	/*
	 * 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);
393
	return 0;
394
}
395
EXPORT_SYMBOL_GPL(omap_dm_timer_stop);
396

397
int omap_dm_timer_set_source(struct omap_dm_timer *timer, int source)
398
{
399
	int ret;
400 401
	char *parent_name = NULL;
	struct clk *fclk, *parent;
402 403 404 405 406 407
	struct dmtimer_platform_data *pdata;

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

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

409
	if (source < 0 || source >= 3)
410
		return -EINVAL;
411

412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
	/*
	 * FIXME: Used for OMAP1 devices only because they do not currently
	 * use the clock framework to set the parent clock. To be removed
	 * once OMAP1 migrated to using clock framework for dmtimers
	 */
	if (pdata->set_timer_src)
		return pdata->set_timer_src(timer->pdev, source);

	fclk = clk_get(&timer->pdev->dev, "fck");
	if (IS_ERR_OR_NULL(fclk)) {
		pr_err("%s: fck not found\n", __func__);
		return -EINVAL;
	}

	switch (source) {
	case OMAP_TIMER_SRC_SYS_CLK:
428
		parent_name = "timer_sys_ck";
429 430 431
		break;

	case OMAP_TIMER_SRC_32_KHZ:
432
		parent_name = "timer_32k_ck";
433 434 435
		break;

	case OMAP_TIMER_SRC_EXT_CLK:
436
		parent_name = "timer_ext_ck";
437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
		break;
	}

	parent = clk_get(&timer->pdev->dev, parent_name);
	if (IS_ERR_OR_NULL(parent)) {
		pr_err("%s: %s not found\n", __func__, parent_name);
		ret = -EINVAL;
		goto out;
	}

	ret = clk_set_parent(fclk, parent);
	if (IS_ERR_VALUE(ret))
		pr_err("%s: failed to set %s as parent\n", __func__,
			parent_name);

	clk_put(parent);
out:
	clk_put(fclk);
455 456

	return ret;
457
}
458
EXPORT_SYMBOL_GPL(omap_dm_timer_set_source);
459

460
int omap_dm_timer_set_load(struct omap_dm_timer *timer, int autoreload,
461
			    unsigned int load)
462 463
{
	u32 l;
464

465 466 467
	if (unlikely(!timer))
		return -EINVAL;

468
	omap_dm_timer_enable(timer);
469
	l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
470 471 472 473
	if (autoreload)
		l |= OMAP_TIMER_CTRL_AR;
	else
		l &= ~OMAP_TIMER_CTRL_AR;
474
	omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
475
	omap_dm_timer_write_reg(timer, OMAP_TIMER_LOAD_REG, load);
476

477
	omap_dm_timer_write_reg(timer, OMAP_TIMER_TRIGGER_REG, 0);
478 479 480 481
	/* Save the context */
	timer->context.tclr = l;
	timer->context.tldr = load;
	omap_dm_timer_disable(timer);
482
	return 0;
483
}
484
EXPORT_SYMBOL_GPL(omap_dm_timer_set_load);
485

486
/* Optimized set_load which removes costly spin wait in timer_start */
487
int omap_dm_timer_set_load_start(struct omap_dm_timer *timer, int autoreload,
488 489 490 491
                            unsigned int load)
{
	u32 l;

492 493 494
	if (unlikely(!timer))
		return -EINVAL;

495 496
	omap_dm_timer_enable(timer);

497
	if (!(timer->capability & OMAP_TIMER_ALWON)) {
498 499
		if (omap_pm_get_dev_context_loss_count(&timer->pdev->dev) !=
				timer->ctx_loss_count)
500 501 502
			omap_timer_restore_context(timer);
	}

503
	l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
504
	if (autoreload) {
505
		l |= OMAP_TIMER_CTRL_AR;
506 507
		omap_dm_timer_write_reg(timer, OMAP_TIMER_LOAD_REG, load);
	} else {
508
		l &= ~OMAP_TIMER_CTRL_AR;
509
	}
510 511
	l |= OMAP_TIMER_CTRL_ST;

512
	__omap_dm_timer_load_start(timer, l, load, timer->posted);
513 514 515 516 517

	/* Save the context */
	timer->context.tclr = l;
	timer->context.tldr = load;
	timer->context.tcrr = load;
518
	return 0;
519
}
520
EXPORT_SYMBOL_GPL(omap_dm_timer_set_load_start);
521

522
int omap_dm_timer_set_match(struct omap_dm_timer *timer, int enable,
523
			     unsigned int match)
524 525 526
{
	u32 l;

527 528 529
	if (unlikely(!timer))
		return -EINVAL;

530
	omap_dm_timer_enable(timer);
531
	l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
T
Timo Teras 已提交
532
	if (enable)
533 534 535
		l |= OMAP_TIMER_CTRL_CE;
	else
		l &= ~OMAP_TIMER_CTRL_CE;
536
	omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
537
	omap_dm_timer_write_reg(timer, OMAP_TIMER_MATCH_REG, match);
538 539 540 541 542

	/* Save the context */
	timer->context.tclr = l;
	timer->context.tmar = match;
	omap_dm_timer_disable(timer);
543
	return 0;
544
}
545
EXPORT_SYMBOL_GPL(omap_dm_timer_set_match);
546

547
int omap_dm_timer_set_pwm(struct omap_dm_timer *timer, int def_on,
548
			   int toggle, int trigger)
549 550 551
{
	u32 l;

552 553 554
	if (unlikely(!timer))
		return -EINVAL;

555
	omap_dm_timer_enable(timer);
556
	l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
557 558 559 560 561 562 563
	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;
564
	omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
565 566 567 568

	/* Save the context */
	timer->context.tclr = l;
	omap_dm_timer_disable(timer);
569
	return 0;
570
}
571
EXPORT_SYMBOL_GPL(omap_dm_timer_set_pwm);
572

573
int omap_dm_timer_set_prescaler(struct omap_dm_timer *timer, int prescaler)
574 575 576
{
	u32 l;

577 578 579
	if (unlikely(!timer))
		return -EINVAL;

580
	omap_dm_timer_enable(timer);
581
	l = omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG);
582 583 584 585 586
	l &= ~(OMAP_TIMER_CTRL_PRE | (0x07 << 2));
	if (prescaler >= 0x00 && prescaler <= 0x07) {
		l |= OMAP_TIMER_CTRL_PRE;
		l |= prescaler << 2;
	}
587
	omap_dm_timer_write_reg(timer, OMAP_TIMER_CTRL_REG, l);
588 589 590 591

	/* Save the context */
	timer->context.tclr = l;
	omap_dm_timer_disable(timer);
592
	return 0;
593
}
594
EXPORT_SYMBOL_GPL(omap_dm_timer_set_prescaler);
595

596
int omap_dm_timer_set_int_enable(struct omap_dm_timer *timer,
597
				  unsigned int value)
598
{
599 600 601
	if (unlikely(!timer))
		return -EINVAL;

602
	omap_dm_timer_enable(timer);
603
	__omap_dm_timer_int_enable(timer, value);
604 605 606 607 608

	/* Save the context */
	timer->context.tier = value;
	timer->context.twer = value;
	omap_dm_timer_disable(timer);
609
	return 0;
610
}
611
EXPORT_SYMBOL_GPL(omap_dm_timer_set_int_enable);
612

613
unsigned int omap_dm_timer_read_status(struct omap_dm_timer *timer)
614
{
615 616
	unsigned int l;

617 618
	if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev))) {
		pr_err("%s: timer not available or enabled.\n", __func__);
619 620 621
		return 0;
	}

622
	l = __raw_readl(timer->irq_stat);
623 624

	return l;
625
}
626
EXPORT_SYMBOL_GPL(omap_dm_timer_read_status);
627

628
int omap_dm_timer_write_status(struct omap_dm_timer *timer, unsigned int value)
629
{
630 631 632
	if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev)))
		return -EINVAL;

633
	__omap_dm_timer_write_status(timer, value);
634 635
	/* Save the context */
	timer->context.tisr = value;
636
	return 0;
637
}
638
EXPORT_SYMBOL_GPL(omap_dm_timer_write_status);
639

640
unsigned int omap_dm_timer_read_counter(struct omap_dm_timer *timer)
641
{
642 643
	if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev))) {
		pr_err("%s: timer not iavailable or enabled.\n", __func__);
644 645 646
		return 0;
	}

647
	return __omap_dm_timer_read_counter(timer, timer->posted);
648
}
649
EXPORT_SYMBOL_GPL(omap_dm_timer_read_counter);
650

651
int omap_dm_timer_write_counter(struct omap_dm_timer *timer, unsigned int value)
T
Timo Teras 已提交
652
{
653 654 655
	if (unlikely(!timer || pm_runtime_suspended(&timer->pdev->dev))) {
		pr_err("%s: timer not available or enabled.\n", __func__);
		return -EINVAL;
656 657
	}

658
	omap_dm_timer_write_reg(timer, OMAP_TIMER_COUNTER_REG, value);
659 660 661

	/* Save the context */
	timer->context.tcrr = value;
662
	return 0;
T
Timo Teras 已提交
663
}
664
EXPORT_SYMBOL_GPL(omap_dm_timer_write_counter);
T
Timo Teras 已提交
665

666
int omap_dm_timers_active(void)
667
{
668
	struct omap_dm_timer *timer;
669

670
	list_for_each_entry(timer, &omap_timer_list, node) {
671
		if (!timer->reserved)
672 673
			continue;

674
		if (omap_dm_timer_read_reg(timer, OMAP_TIMER_CTRL_REG) &
675
		    OMAP_TIMER_CTRL_ST) {
676
			return 1;
677
		}
678 679 680
	}
	return 0;
}
681
EXPORT_SYMBOL_GPL(omap_dm_timers_active);
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)
{
	unsigned long flags;
	struct omap_dm_timer *timer;
694 695
	struct resource *mem, *irq;
	struct device *dev = &pdev->dev;
696 697 698
	struct dmtimer_platform_data *pdata = pdev->dev.platform_data;

	if (!pdata) {
699
		dev_err(dev, "%s: no platform data.\n", __func__);
700 701 702 703 704
		return -ENODEV;
	}

	irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (unlikely(!irq)) {
705
		dev_err(dev, "%s: no IRQ resource.\n", __func__);
706 707 708 709 710
		return -ENODEV;
	}

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

715
	timer = devm_kzalloc(dev, sizeof(struct omap_dm_timer), GFP_KERNEL);
716
	if (!timer) {
717 718
		dev_err(dev, "%s: memory alloc failed!\n", __func__);
		return  -ENOMEM;
719 720
	}

721
	timer->io_base = devm_request_and_ioremap(dev, mem);
722
	if (!timer->io_base) {
723 724
		dev_err(dev, "%s: region already claimed.\n", __func__);
		return -ENOMEM;
725 726 727 728
	}

	timer->id = pdev->id;
	timer->irq = irq->start;
729
	timer->reserved = omap_dm_timer_reserved_systimer(timer->id);
730
	timer->pdev = pdev;
731
	timer->capability = pdata->timer_capability;
732

733
	/* Skip pm_runtime_enable for OMAP1 */
734
	if (!(timer->capability & OMAP_TIMER_NEEDS_RESET)) {
735 736
		pm_runtime_enable(dev);
		pm_runtime_irq_safe(dev);
737 738
	}

739
	if (!timer->reserved) {
740
		pm_runtime_get_sync(dev);
741
		__omap_dm_timer_init_regs(timer);
742
		pm_runtime_put(dev);
743 744
	}

745 746 747 748 749
	/* 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);

750
	dev_dbg(dev, "Device Probed.\n");
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782

	return 0;
}

/**
 * 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);
			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,
783
	.remove = __devexit_p(omap_dm_timer_remove),
784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806
	.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");