tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge branch 'rtc-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip

* 'rtc-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
RTC: Fix minor compile warning
RTC: Convert rtc drivers to use the alarm_irq_enable method
RTC: Fix rtc driver ioctl specific shortcutting

Linus Torvalds f1b6a4ec 795abaf1

+232 -313
+6 -13
drivers/rtc/rtc-at32ap700x.c
··· 134 134 return ret; 135 135 } 136 136 137 - static int at32_rtc_ioctl(struct device *dev, unsigned int cmd, 138 - unsigned long arg) 137 + static int at32_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 139 138 { 140 139 struct rtc_at32ap700x *rtc = dev_get_drvdata(dev); 141 140 int ret = 0; 142 141 143 142 spin_lock_irq(&rtc->lock); 144 143 145 - switch (cmd) { 146 - case RTC_AIE_ON: 144 + if(enabled) { 147 145 if (rtc_readl(rtc, VAL) > rtc->alarm_time) { 148 146 ret = -EINVAL; 149 - break; 147 + goto out; 150 148 } 151 149 rtc_writel(rtc, CTRL, rtc_readl(rtc, CTRL) 152 150 | RTC_BIT(CTRL_TOPEN)); 153 151 rtc_writel(rtc, ICR, RTC_BIT(ICR_TOPI)); 154 152 rtc_writel(rtc, IER, RTC_BIT(IER_TOPI)); 155 - break; 156 - case RTC_AIE_OFF: 153 + } else { 157 154 rtc_writel(rtc, CTRL, rtc_readl(rtc, CTRL) 158 155 & ~RTC_BIT(CTRL_TOPEN)); 159 156 rtc_writel(rtc, IDR, RTC_BIT(IDR_TOPI)); 160 157 rtc_writel(rtc, ICR, RTC_BIT(ICR_TOPI)); 161 - break; 162 - default: 163 - ret = -ENOIOCTLCMD; 164 - break; 165 158 } 166 - 159 + out: 167 160 spin_unlock_irq(&rtc->lock); 168 161 169 162 return ret; ··· 188 195 } 189 196 190 197 static struct rtc_class_ops at32_rtc_ops = { 191 - .ioctl = at32_rtc_ioctl, 192 198 .read_time = at32_rtc_readtime, 193 199 .set_time = at32_rtc_settime, 194 200 .read_alarm = at32_rtc_readalarm, 195 201 .set_alarm = at32_rtc_setalarm, 202 + .alarm_irq_enable = at32_rtc_alarm_irq_enable, 196 203 }; 197 204 198 205 static int __init at32_rtc_probe(struct platform_device *pdev)
+13 -7
drivers/rtc/rtc-at91rm9200.c
··· 195 195 196 196 /* important: scrub old status before enabling IRQs */ 197 197 switch (cmd) { 198 - case RTC_AIE_OFF: /* alarm off */ 199 - at91_sys_write(AT91_RTC_IDR, AT91_RTC_ALARM); 200 - break; 201 - case RTC_AIE_ON: /* alarm on */ 202 - at91_sys_write(AT91_RTC_SCCR, AT91_RTC_ALARM); 203 - at91_sys_write(AT91_RTC_IER, AT91_RTC_ALARM); 204 - break; 205 198 case RTC_UIE_OFF: /* update off */ 206 199 at91_sys_write(AT91_RTC_IDR, AT91_RTC_SECEV); 207 200 break; ··· 210 217 return ret; 211 218 } 212 219 220 + static int at91_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 221 + { 222 + pr_debug("%s(): cmd=%08x\n", __func__, enabled); 223 + 224 + if (enabled) { 225 + at91_sys_write(AT91_RTC_SCCR, AT91_RTC_ALARM); 226 + at91_sys_write(AT91_RTC_IER, AT91_RTC_ALARM); 227 + } else 228 + at91_sys_write(AT91_RTC_IDR, AT91_RTC_ALARM); 229 + 230 + return 0; 231 + } 213 232 /* 214 233 * Provide additional RTC information in /proc/driver/rtc 215 234 */ ··· 275 270 .read_alarm = at91_rtc_readalarm, 276 271 .set_alarm = at91_rtc_setalarm, 277 272 .proc = at91_rtc_proc, 273 + .alarm_irq_enable = at91_rtc_alarm_irq_enable, 278 274 }; 279 275 280 276 /*
+14 -6
drivers/rtc/rtc-at91sam9.c
··· 229 229 dev_dbg(dev, "ioctl: cmd=%08x, arg=%08lx, mr %08x\n", cmd, arg, mr); 230 230 231 231 switch (cmd) { 232 - case RTC_AIE_OFF: /* alarm off */ 233 - rtt_writel(rtc, MR, mr & ~AT91_RTT_ALMIEN); 234 - break; 235 - case RTC_AIE_ON: /* alarm on */ 236 - rtt_writel(rtc, MR, mr | AT91_RTT_ALMIEN); 237 - break; 238 232 case RTC_UIE_OFF: /* update off */ 239 233 rtt_writel(rtc, MR, mr & ~AT91_RTT_RTTINCIEN); 240 234 break; ··· 241 247 } 242 248 243 249 return ret; 250 + } 251 + 252 + static int at91_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 253 + { 254 + struct sam9_rtc *rtc = dev_get_drvdata(dev); 255 + u32 mr = rtt_readl(rtc, MR); 256 + 257 + dev_dbg(dev, "alarm_irq_enable: enabled=%08x, mr %08x\n", enabled, mr); 258 + if (enabled) 259 + rtt_writel(rtc, MR, mr | AT91_RTT_ALMIEN); 260 + else 261 + rtt_writel(rtc, MR, mr & ~AT91_RTT_ALMIEN); 262 + return 0; 244 263 } 245 264 246 265 /* ··· 309 302 .read_alarm = at91_rtc_readalarm, 310 303 .set_alarm = at91_rtc_setalarm, 311 304 .proc = at91_rtc_proc, 305 + .alarm_irq_enabled = at91_rtc_alarm_irq_enable, 312 306 }; 313 307 314 308 /*
+12 -9
drivers/rtc/rtc-bfin.c
··· 259 259 bfin_rtc_int_clear(~RTC_ISTAT_SEC); 260 260 break; 261 261 262 - case RTC_AIE_ON: 263 - dev_dbg_stamp(dev); 264 - bfin_rtc_int_set_alarm(rtc); 265 - break; 266 - case RTC_AIE_OFF: 267 - dev_dbg_stamp(dev); 268 - bfin_rtc_int_clear(~(RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY)); 269 - break; 270 - 271 262 default: 272 263 dev_dbg_stamp(dev); 273 264 ret = -ENOIOCTLCMD; 274 265 } 275 266 276 267 return ret; 268 + } 269 + 270 + static int bfin_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 271 + { 272 + struct bfin_rtc *rtc = dev_get_drvdata(dev); 273 + 274 + dev_dbg_stamp(dev); 275 + if (enabled) 276 + bfin_rtc_int_set_alarm(rtc); 277 + else 278 + bfin_rtc_int_clear(~(RTC_ISTAT_ALARM | RTC_ISTAT_ALARM_DAY)); 277 279 } 278 280 279 281 static int bfin_rtc_read_time(struct device *dev, struct rtc_time *tm) ··· 364 362 .read_alarm = bfin_rtc_read_alarm, 365 363 .set_alarm = bfin_rtc_set_alarm, 366 364 .proc = bfin_rtc_proc, 365 + .alarm_irq_enable = bfin_rtc_alarm_irq_enable, 367 366 }; 368 367 369 368 static int __devinit bfin_rtc_probe(struct platform_device *pdev)
+7 -14
drivers/rtc/rtc-dev.c
··· 154 154 if (err) 155 155 goto done; 156 156 157 - /* try the driver's ioctl interface */ 158 - if (ops->ioctl) { 159 - err = ops->ioctl(rtc->dev.parent, cmd, arg); 160 - if (err != -ENOIOCTLCMD) { 161 - mutex_unlock(&rtc->ops_lock); 162 - return err; 163 - } 164 - } 165 - 166 - /* if the driver does not provide the ioctl interface 167 - * or if that particular ioctl was not implemented 168 - * (-ENOIOCTLCMD), we will try to emulate here. 169 - * 157 + /* 170 158 * Drivers *SHOULD NOT* provide ioctl implementations 171 159 * for these requests. Instead, provide methods to 172 160 * support the following code, so that the RTC's main ··· 317 329 return err; 318 330 319 331 default: 320 - err = -ENOTTY; 332 + /* Finally try the driver's ioctl interface */ 333 + if (ops->ioctl) { 334 + err = ops->ioctl(rtc->dev.parent, cmd, arg); 335 + if (err == -ENOIOCTLCMD) 336 + err = -ENOTTY; 337 + } 321 338 break; 322 339 } 323 340
+23 -18
drivers/rtc/rtc-ds1286.c
··· 40 40 __raw_writel(data, &priv->rtcregs[reg]); 41 41 } 42 42 43 + 44 + static int ds1286_alarm_irq_enable(struct device *dev, unsigned int enabled) 45 + { 46 + struct ds1286_priv *priv = dev_get_drvdata(dev); 47 + unsigned long flags; 48 + unsigned char val; 49 + 50 + /* Allow or mask alarm interrupts */ 51 + spin_lock_irqsave(&priv->lock, flags); 52 + val = ds1286_rtc_read(priv, RTC_CMD); 53 + if (enabled) 54 + val &= ~RTC_TDM; 55 + else 56 + val |= RTC_TDM; 57 + ds1286_rtc_write(priv, val, RTC_CMD); 58 + spin_unlock_irqrestore(&priv->lock, flags); 59 + 60 + return 0; 61 + } 62 + 43 63 #ifdef CONFIG_RTC_INTF_DEV 44 64 45 65 static int ds1286_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) ··· 69 49 unsigned char val; 70 50 71 51 switch (cmd) { 72 - case RTC_AIE_OFF: 73 - /* Mask alarm int. enab. bit */ 74 - spin_lock_irqsave(&priv->lock, flags); 75 - val = ds1286_rtc_read(priv, RTC_CMD); 76 - val |= RTC_TDM; 77 - ds1286_rtc_write(priv, val, RTC_CMD); 78 - spin_unlock_irqrestore(&priv->lock, flags); 79 - break; 80 - case RTC_AIE_ON: 81 - /* Allow alarm interrupts. */ 82 - spin_lock_irqsave(&priv->lock, flags); 83 - val = ds1286_rtc_read(priv, RTC_CMD); 84 - val &= ~RTC_TDM; 85 - ds1286_rtc_write(priv, val, RTC_CMD); 86 - spin_unlock_irqrestore(&priv->lock, flags); 87 - break; 88 52 case RTC_WIE_OFF: 89 53 /* Mask watchdog int. enab. bit */ 90 54 spin_lock_irqsave(&priv->lock, flags); ··· 320 316 } 321 317 322 318 static const struct rtc_class_ops ds1286_ops = { 323 - .ioctl = ds1286_ioctl, 324 - .proc = ds1286_proc, 319 + .ioctl = ds1286_ioctl, 320 + .proc = ds1286_proc, 325 321 .read_time = ds1286_read_time, 326 322 .set_time = ds1286_set_time, 327 323 .read_alarm = ds1286_read_alarm, 328 324 .set_alarm = ds1286_set_alarm, 325 + .alarm_irq_enable = ds1286_alarm_irq_enable, 329 326 }; 330 327 331 328 static int __devinit ds1286_probe(struct platform_device *pdev)
+13 -30
drivers/rtc/rtc-ds1305.c
··· 139 139 * Interface to RTC framework 140 140 */ 141 141 142 - #ifdef CONFIG_RTC_INTF_DEV 143 - 144 - /* 145 - * Context: caller holds rtc->ops_lock (to protect ds1305->ctrl) 146 - */ 147 - static int ds1305_ioctl(struct device *dev, unsigned cmd, unsigned long arg) 142 + static int ds1305_alarm_irq_enable(struct device *dev, unsigned int enabled) 148 143 { 149 144 struct ds1305 *ds1305 = dev_get_drvdata(dev); 150 145 u8 buf[2]; 151 - int status = -ENOIOCTLCMD; 146 + long err = -EINVAL; 152 147 153 148 buf[0] = DS1305_WRITE | DS1305_CONTROL; 154 149 buf[1] = ds1305->ctrl[0]; 155 150 156 - switch (cmd) { 157 - case RTC_AIE_OFF: 158 - status = 0; 159 - if (!(buf[1] & DS1305_AEI0)) 160 - goto done; 161 - buf[1] &= ~DS1305_AEI0; 162 - break; 163 - 164 - case RTC_AIE_ON: 165 - status = 0; 151 + if (enabled) { 166 152 if (ds1305->ctrl[0] & DS1305_AEI0) 167 153 goto done; 168 154 buf[1] |= DS1305_AEI0; 169 - break; 155 + } else { 156 + if (!(buf[1] & DS1305_AEI0)) 157 + goto done; 158 + buf[1] &= ~DS1305_AEI0; 170 159 } 171 - if (status == 0) { 172 - status = spi_write_then_read(ds1305->spi, buf, sizeof buf, 173 - NULL, 0); 174 - if (status >= 0) 175 - ds1305->ctrl[0] = buf[1]; 176 - } 177 - 160 + err = spi_write_then_read(ds1305->spi, buf, sizeof buf, NULL, 0); 161 + if (err >= 0) 162 + ds1305->ctrl[0] = buf[1]; 178 163 done: 179 - return status; 164 + return err; 165 + 180 166 } 181 167 182 - #else 183 - #define ds1305_ioctl NULL 184 - #endif 185 168 186 169 /* 187 170 * Get/set of date and time is pretty normal. ··· 443 460 #endif 444 461 445 462 static const struct rtc_class_ops ds1305_ops = { 446 - .ioctl = ds1305_ioctl, 447 463 .read_time = ds1305_get_time, 448 464 .set_time = ds1305_set_time, 449 465 .read_alarm = ds1305_get_alarm, 450 466 .set_alarm = ds1305_set_alarm, 451 467 .proc = ds1305_proc, 468 + .alarm_irq_enable = ds1305_alarm_irq_enable, 452 469 }; 453 470 454 471 static void ds1305_work(struct work_struct *work)
+13 -36
drivers/rtc/rtc-ds1307.c
··· 495 495 return 0; 496 496 } 497 497 498 - static int ds1307_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 498 + static int ds1307_alarm_irq_enable(struct device *dev, unsigned int enabled) 499 499 { 500 500 struct i2c_client *client = to_i2c_client(dev); 501 501 struct ds1307 *ds1307 = i2c_get_clientdata(client); 502 502 int ret; 503 503 504 - switch (cmd) { 505 - case RTC_AIE_OFF: 506 - if (!test_bit(HAS_ALARM, &ds1307->flags)) 507 - return -ENOTTY; 504 + if (!test_bit(HAS_ALARM, &ds1307->flags)) 505 + return -ENOTTY; 508 506 509 - ret = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL); 510 - if (ret < 0) 511 - return ret; 507 + ret = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL); 508 + if (ret < 0) 509 + return ret; 512 510 511 + if (enabled) 512 + ret |= DS1337_BIT_A1IE; 513 + else 513 514 ret &= ~DS1337_BIT_A1IE; 514 515 515 - ret = i2c_smbus_write_byte_data(client, 516 - DS1337_REG_CONTROL, ret); 517 - if (ret < 0) 518 - return ret; 519 - 520 - break; 521 - 522 - case RTC_AIE_ON: 523 - if (!test_bit(HAS_ALARM, &ds1307->flags)) 524 - return -ENOTTY; 525 - 526 - ret = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL); 527 - if (ret < 0) 528 - return ret; 529 - 530 - ret |= DS1337_BIT_A1IE; 531 - 532 - ret = i2c_smbus_write_byte_data(client, 533 - DS1337_REG_CONTROL, ret); 534 - if (ret < 0) 535 - return ret; 536 - 537 - break; 538 - 539 - default: 540 - return -ENOIOCTLCMD; 541 - } 516 + ret = i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL, ret); 517 + if (ret < 0) 518 + return ret; 542 519 543 520 return 0; 544 521 } ··· 525 548 .set_time = ds1307_set_time, 526 549 .read_alarm = ds1337_read_alarm, 527 550 .set_alarm = ds1337_set_alarm, 528 - .ioctl = ds1307_ioctl, 551 + .alarm_irq_enable = ds1307_alarm_irq_enable, 529 552 }; 530 553 531 554 /*----------------------------------------------------------------------*/
+10 -27
drivers/rtc/rtc-ds1374.c
··· 307 307 mutex_unlock(&ds1374->mutex); 308 308 } 309 309 310 - static int ds1374_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 310 + static int ds1374_alarm_irq_enable(struct device *dev, unsigned int enabled) 311 311 { 312 312 struct i2c_client *client = to_i2c_client(dev); 313 313 struct ds1374 *ds1374 = i2c_get_clientdata(client); 314 - int ret = -ENOIOCTLCMD; 314 + int ret; 315 315 316 316 mutex_lock(&ds1374->mutex); 317 317 318 - switch (cmd) { 319 - case RTC_AIE_OFF: 320 - ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 321 - if (ret < 0) 322 - goto out; 318 + ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 319 + if (ret < 0) 320 + goto out; 323 321 324 - ret &= ~DS1374_REG_CR_WACE; 325 - 326 - ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret); 327 - if (ret < 0) 328 - goto out; 329 - 330 - break; 331 - 332 - case RTC_AIE_ON: 333 - ret = i2c_smbus_read_byte_data(client, DS1374_REG_CR); 334 - if (ret < 0) 335 - goto out; 336 - 322 + if (enabled) { 337 323 ret |= DS1374_REG_CR_WACE | DS1374_REG_CR_AIE; 338 324 ret &= ~DS1374_REG_CR_WDALM; 339 - 340 - ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret); 341 - if (ret < 0) 342 - goto out; 343 - 344 - break; 325 + } else { 326 + ret &= ~DS1374_REG_CR_WACE; 345 327 } 328 + ret = i2c_smbus_write_byte_data(client, DS1374_REG_CR, ret); 346 329 347 330 out: 348 331 mutex_unlock(&ds1374->mutex); ··· 337 354 .set_time = ds1374_set_time, 338 355 .read_alarm = ds1374_read_alarm, 339 356 .set_alarm = ds1374_set_alarm, 340 - .ioctl = ds1374_ioctl, 357 + .alarm_irq_enable = ds1374_alarm_irq_enable, 341 358 }; 342 359 343 360 static int ds1374_probe(struct i2c_client *client,
+8 -22
drivers/rtc/rtc-m41t80.c
··· 213 213 return m41t80_set_datetime(to_i2c_client(dev), tm); 214 214 } 215 215 216 - #if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE) 217 - static int 218 - m41t80_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 216 + static int m41t80_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 219 217 { 220 218 struct i2c_client *client = to_i2c_client(dev); 221 219 int rc; 222 220 223 - switch (cmd) { 224 - case RTC_AIE_OFF: 225 - case RTC_AIE_ON: 226 - break; 227 - default: 228 - return -ENOIOCTLCMD; 229 - } 230 - 231 221 rc = i2c_smbus_read_byte_data(client, M41T80_REG_ALARM_MON); 232 222 if (rc < 0) 233 223 goto err; 234 - switch (cmd) { 235 - case RTC_AIE_OFF: 236 - rc &= ~M41T80_ALMON_AFE; 237 - break; 238 - case RTC_AIE_ON: 224 + 225 + if (enabled) 239 226 rc |= M41T80_ALMON_AFE; 240 - break; 241 - } 227 + else 228 + rc &= ~M41T80_ALMON_AFE; 229 + 242 230 if (i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON, rc) < 0) 243 231 goto err; 232 + 244 233 return 0; 245 234 err: 246 235 return -EIO; 247 236 } 248 - #else 249 - #define m41t80_rtc_ioctl NULL 250 - #endif 251 237 252 238 static int m41t80_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *t) 253 239 { ··· 360 374 .read_alarm = m41t80_rtc_read_alarm, 361 375 .set_alarm = m41t80_rtc_set_alarm, 362 376 .proc = m41t80_rtc_proc, 363 - .ioctl = m41t80_rtc_ioctl, 377 + .alarm_irq_enable = m41t80_rtc_alarm_irq_enable, 364 378 }; 365 379 366 380 #if defined(CONFIG_RTC_INTF_SYSFS) || defined(CONFIG_RTC_INTF_SYSFS_MODULE)
+6 -15
drivers/rtc/rtc-m48t59.c
··· 263 263 /* 264 264 * Handle commands from user-space 265 265 */ 266 - static int m48t59_rtc_ioctl(struct device *dev, unsigned int cmd, 267 - unsigned long arg) 266 + static int m48t59_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 268 267 { 269 268 struct platform_device *pdev = to_platform_device(dev); 270 269 struct m48t59_plat_data *pdata = pdev->dev.platform_data; 271 270 struct m48t59_private *m48t59 = platform_get_drvdata(pdev); 272 271 unsigned long flags; 273 - int ret = 0; 274 272 275 273 spin_lock_irqsave(&m48t59->lock, flags); 276 - switch (cmd) { 277 - case RTC_AIE_OFF: /* alarm interrupt off */ 278 - M48T59_WRITE(0x00, M48T59_INTR); 279 - break; 280 - case RTC_AIE_ON: /* alarm interrupt on */ 274 + if (enabled) 281 275 M48T59_WRITE(M48T59_INTR_AFE, M48T59_INTR); 282 - break; 283 - default: 284 - ret = -ENOIOCTLCMD; 285 - break; 286 - } 276 + else 277 + M48T59_WRITE(0x00, M48T59_INTR); 287 278 spin_unlock_irqrestore(&m48t59->lock, flags); 288 279 289 - return ret; 280 + return 0; 290 281 } 291 282 292 283 static int m48t59_rtc_proc(struct device *dev, struct seq_file *seq) ··· 321 330 } 322 331 323 332 static const struct rtc_class_ops m48t59_rtc_ops = { 324 - .ioctl = m48t59_rtc_ioctl, 325 333 .read_time = m48t59_rtc_read_time, 326 334 .set_time = m48t59_rtc_set_time, 327 335 .read_alarm = m48t59_rtc_readalarm, 328 336 .set_alarm = m48t59_rtc_setalarm, 329 337 .proc = m48t59_rtc_proc, 338 + .alarm_irq_enable = m48t59_rtc_alarm_irq_enable, 330 339 }; 331 340 332 341 static const struct rtc_class_ops m48t02_rtc_ops = {
+5 -26
drivers/rtc/rtc-mrst.c
··· 255 255 return 0; 256 256 } 257 257 258 - #if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE) 259 - 260 258 /* Currently, the vRTC doesn't support UIE ON/OFF */ 261 - static int 262 - mrst_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 259 + static int mrst_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 263 260 { 264 261 struct mrst_rtc *mrst = dev_get_drvdata(dev); 265 262 unsigned long flags; 266 263 267 - switch (cmd) { 268 - case RTC_AIE_OFF: 269 - case RTC_AIE_ON: 270 - if (!mrst->irq) 271 - return -EINVAL; 272 - break; 273 - default: 274 - /* PIE ON/OFF is handled by mrst_irq_set_state() */ 275 - return -ENOIOCTLCMD; 276 - } 277 - 278 264 spin_lock_irqsave(&rtc_lock, flags); 279 - switch (cmd) { 280 - case RTC_AIE_OFF: /* alarm off */ 281 - mrst_irq_disable(mrst, RTC_AIE); 282 - break; 283 - case RTC_AIE_ON: /* alarm on */ 265 + if (enabled) 284 266 mrst_irq_enable(mrst, RTC_AIE); 285 - break; 286 - } 267 + else 268 + mrst_irq_disable(mrst, RTC_AIE); 287 269 spin_unlock_irqrestore(&rtc_lock, flags); 288 270 return 0; 289 271 } 290 272 291 - #else 292 - #define mrst_rtc_ioctl NULL 293 - #endif 294 273 295 274 #if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE) 296 275 ··· 296 317 #endif 297 318 298 319 static const struct rtc_class_ops mrst_rtc_ops = { 299 - .ioctl = mrst_rtc_ioctl, 300 320 .read_time = mrst_read_time, 301 321 .set_time = mrst_set_time, 302 322 .read_alarm = mrst_read_alarm, 303 323 .set_alarm = mrst_set_alarm, 304 324 .proc = mrst_procfs, 305 325 .irq_set_state = mrst_irq_set_state, 326 + .alarm_irq_enable = mrst_rtc_alarm_irq_enable, 306 327 }; 307 328 308 329 static struct mrst_rtc mrst_rtc;
+1 -1
drivers/rtc/rtc-msm6242.c
··· 82 82 static inline void msm6242_write(struct msm6242_priv *priv, unsigned int val, 83 83 unsigned int reg) 84 84 { 85 - return __raw_writel(val, &priv->regs[reg]); 85 + __raw_writel(val, &priv->regs[reg]); 86 86 } 87 87 88 88 static inline void msm6242_set(struct msm6242_priv *priv, unsigned int val,
+7 -13
drivers/rtc/rtc-mv.c
··· 169 169 return 0; 170 170 } 171 171 172 - static int mv_rtc_ioctl(struct device *dev, unsigned int cmd, 173 - unsigned long arg) 172 + static int mv_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 174 173 { 175 174 struct platform_device *pdev = to_platform_device(dev); 176 175 struct rtc_plat_data *pdata = platform_get_drvdata(pdev); 177 176 void __iomem *ioaddr = pdata->ioaddr; 178 177 179 178 if (pdata->irq < 0) 180 - return -ENOIOCTLCMD; /* fall back into rtc-dev's emulation */ 181 - switch (cmd) { 182 - case RTC_AIE_OFF: 183 - writel(0, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS); 184 - break; 185 - case RTC_AIE_ON: 179 + return -EINVAL; /* fall back into rtc-dev's emulation */ 180 + 181 + if (enabled) 186 182 writel(1, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS); 187 - break; 188 - default: 189 - return -ENOIOCTLCMD; 190 - } 183 + else 184 + writel(0, ioaddr + RTC_ALARM_INTERRUPT_MASK_REG_OFFS); 191 185 return 0; 192 186 } 193 187 ··· 210 216 .set_time = mv_rtc_set_time, 211 217 .read_alarm = mv_rtc_read_alarm, 212 218 .set_alarm = mv_rtc_set_alarm, 213 - .ioctl = mv_rtc_ioctl, 219 + .alarm_irq_enable = mv_rtc_alarm_irq_enable, 214 220 }; 215 221 216 222 static int __devinit mv_rtc_probe(struct platform_device *pdev)
+19 -9
drivers/rtc/rtc-omap.c
··· 143 143 u8 reg; 144 144 145 145 switch (cmd) { 146 - case RTC_AIE_OFF: 147 - case RTC_AIE_ON: 148 146 case RTC_UIE_OFF: 149 147 case RTC_UIE_ON: 150 148 break; ··· 154 156 rtc_wait_not_busy(); 155 157 reg = rtc_read(OMAP_RTC_INTERRUPTS_REG); 156 158 switch (cmd) { 157 - /* AIE = Alarm Interrupt Enable */ 158 - case RTC_AIE_OFF: 159 - reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM; 160 - break; 161 - case RTC_AIE_ON: 162 - reg |= OMAP_RTC_INTERRUPTS_IT_ALARM; 163 - break; 164 159 /* UIE = Update Interrupt Enable (1/second) */ 165 160 case RTC_UIE_OFF: 166 161 reg &= ~OMAP_RTC_INTERRUPTS_IT_TIMER; ··· 172 181 #else 173 182 #define omap_rtc_ioctl NULL 174 183 #endif 184 + 185 + static int omap_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 186 + { 187 + u8 reg; 188 + 189 + local_irq_disable(); 190 + rtc_wait_not_busy(); 191 + reg = rtc_read(OMAP_RTC_INTERRUPTS_REG); 192 + if (enabled) 193 + reg |= OMAP_RTC_INTERRUPTS_IT_ALARM; 194 + else 195 + reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM; 196 + rtc_wait_not_busy(); 197 + rtc_write(reg, OMAP_RTC_INTERRUPTS_REG); 198 + local_irq_enable(); 199 + 200 + return 0; 201 + } 175 202 176 203 /* this hardware doesn't support "don't care" alarm fields */ 177 204 static int tm2bcd(struct rtc_time *tm) ··· 318 309 .set_time = omap_rtc_set_time, 319 310 .read_alarm = omap_rtc_read_alarm, 320 311 .set_alarm = omap_rtc_set_alarm, 312 + .alarm_irq_enable = omap_rtc_alarm_irq_enable, 321 313 }; 322 314 323 315 static int omap_rtc_alarm;
+1 -1
drivers/rtc/rtc-rp5c01.c
··· 76 76 static inline void rp5c01_write(struct rp5c01_priv *priv, unsigned int val, 77 77 unsigned int reg) 78 78 { 79 - return __raw_writel(val, &priv->regs[reg]); 79 + __raw_writel(val, &priv->regs[reg]); 80 80 } 81 81 82 82 static void rp5c01_lock(struct rp5c01_priv *priv)
+34 -14
drivers/rtc/rtc-rs5c372.c
··· 299 299 if (rs5c->type == rtc_rs5c372a 300 300 && (buf & RS5C372A_CTRL1_SL1)) 301 301 return -ENOIOCTLCMD; 302 - case RTC_AIE_OFF: 303 - case RTC_AIE_ON: 304 - /* these irq management calls only make sense for chips 305 - * which are wired up to an IRQ. 306 - */ 307 - if (!rs5c->has_irq) 308 - return -ENOIOCTLCMD; 309 - break; 310 302 default: 311 303 return -ENOIOCTLCMD; 312 304 } ··· 309 317 310 318 addr = RS5C_ADDR(RS5C_REG_CTRL1); 311 319 switch (cmd) { 312 - case RTC_AIE_OFF: /* alarm off */ 313 - buf &= ~RS5C_CTRL1_AALE; 314 - break; 315 - case RTC_AIE_ON: /* alarm on */ 316 - buf |= RS5C_CTRL1_AALE; 317 - break; 318 320 case RTC_UIE_OFF: /* update off */ 319 321 buf &= ~RS5C_CTRL1_CT_MASK; 320 322 break; ··· 331 345 #else 332 346 #define rs5c_rtc_ioctl NULL 333 347 #endif 348 + 349 + 350 + static int rs5c_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 351 + { 352 + struct i2c_client *client = to_i2c_client(dev); 353 + struct rs5c372 *rs5c = i2c_get_clientdata(client); 354 + unsigned char buf; 355 + int status, addr; 356 + 357 + buf = rs5c->regs[RS5C_REG_CTRL1]; 358 + 359 + if (!rs5c->has_irq) 360 + return -EINVAL; 361 + 362 + status = rs5c_get_regs(rs5c); 363 + if (status < 0) 364 + return status; 365 + 366 + addr = RS5C_ADDR(RS5C_REG_CTRL1); 367 + if (enabled) 368 + buf |= RS5C_CTRL1_AALE; 369 + else 370 + buf &= ~RS5C_CTRL1_AALE; 371 + 372 + if (i2c_smbus_write_byte_data(client, addr, buf) < 0) { 373 + printk(KERN_WARNING "%s: can't update alarm\n", 374 + rs5c->rtc->name); 375 + status = -EIO; 376 + } else 377 + rs5c->regs[RS5C_REG_CTRL1] = buf; 378 + 379 + return status; 380 + } 334 381 335 382 336 383 /* NOTE: Since RTC_WKALM_{RD,SET} were originally defined for EFI, ··· 485 466 .set_time = rs5c372_rtc_set_time, 486 467 .read_alarm = rs5c_read_alarm, 487 468 .set_alarm = rs5c_set_alarm, 469 + .alarm_irq_enable = rs5c_rtc_alarm_irq_enable, 488 470 }; 489 471 490 472 #if defined(CONFIG_RTC_INTF_SYSFS) || defined(CONFIG_RTC_INTF_SYSFS_MODULE)
+12 -10
drivers/rtc/rtc-sa1100.c
··· 314 314 unsigned long arg) 315 315 { 316 316 switch (cmd) { 317 - case RTC_AIE_OFF: 318 - spin_lock_irq(&sa1100_rtc_lock); 319 - RTSR &= ~RTSR_ALE; 320 - spin_unlock_irq(&sa1100_rtc_lock); 321 - return 0; 322 - case RTC_AIE_ON: 323 - spin_lock_irq(&sa1100_rtc_lock); 324 - RTSR |= RTSR_ALE; 325 - spin_unlock_irq(&sa1100_rtc_lock); 326 - return 0; 327 317 case RTC_UIE_OFF: 328 318 spin_lock_irq(&sa1100_rtc_lock); 329 319 RTSR &= ~RTSR_HZE; ··· 326 336 return 0; 327 337 } 328 338 return -ENOIOCTLCMD; 339 + } 340 + 341 + static int sa1100_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 342 + { 343 + spin_lock_irq(&sa1100_rtc_lock); 344 + if (enabled) 345 + RTSR |= RTSR_ALE; 346 + else 347 + RTSR &= ~RTSR_ALE; 348 + spin_unlock_irq(&sa1100_rtc_lock); 349 + return 0; 329 350 } 330 351 331 352 static int sa1100_rtc_read_time(struct device *dev, struct rtc_time *tm) ··· 411 410 .proc = sa1100_rtc_proc, 412 411 .irq_set_freq = sa1100_irq_set_freq, 413 412 .irq_set_state = sa1100_irq_set_state, 413 + .alarm_irq_enable = sa1100_rtc_alarm_irq_enable, 414 414 }; 415 415 416 416 static int sa1100_rtc_probe(struct platform_device *pdev)
+7 -4
drivers/rtc/rtc-sh.c
··· 350 350 unsigned int ret = 0; 351 351 352 352 switch (cmd) { 353 - case RTC_AIE_OFF: 354 - case RTC_AIE_ON: 355 - sh_rtc_setaie(dev, cmd == RTC_AIE_ON); 356 - break; 357 353 case RTC_UIE_OFF: 358 354 rtc->periodic_freq &= ~PF_OXS; 359 355 sh_rtc_setcie(dev, 0); ··· 363 367 } 364 368 365 369 return ret; 370 + } 371 + 372 + static int sh_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 373 + { 374 + sh_rtc_setaie(dev, enabled); 375 + return 0; 366 376 } 367 377 368 378 static int sh_rtc_read_time(struct device *dev, struct rtc_time *tm) ··· 606 604 .irq_set_state = sh_rtc_irq_set_state, 607 605 .irq_set_freq = sh_rtc_irq_set_freq, 608 606 .proc = sh_rtc_proc, 607 + .alarm_irq_enable = sh_rtc_alarm_irq_enable, 609 608 }; 610 609 611 610 static int __init sh_rtc_probe(struct platform_device *pdev)
+3 -18
drivers/rtc/rtc-test.c
··· 50 50 return 0; 51 51 } 52 52 53 - static int test_rtc_ioctl(struct device *dev, unsigned int cmd, 54 - unsigned long arg) 53 + static int test_rtc_alarm_irq_enable(struct device *dev, unsigned int enable) 55 54 { 56 - /* We do support interrupts, they're generated 57 - * using the sysfs interface. 58 - */ 59 - switch (cmd) { 60 - case RTC_PIE_ON: 61 - case RTC_PIE_OFF: 62 - case RTC_UIE_ON: 63 - case RTC_UIE_OFF: 64 - case RTC_AIE_ON: 65 - case RTC_AIE_OFF: 66 - return 0; 67 - 68 - default: 69 - return -ENOIOCTLCMD; 70 - } 55 + return 0; 71 56 } 72 57 73 58 static const struct rtc_class_ops test_rtc_ops = { ··· 61 76 .read_alarm = test_rtc_read_alarm, 62 77 .set_alarm = test_rtc_set_alarm, 63 78 .set_mmss = test_rtc_set_mmss, 64 - .ioctl = test_rtc_ioctl, 79 + .alarm_irq_enable = test_rtc_alarm_irq_enable, 65 80 }; 66 81 67 82 static ssize_t test_irq_show(struct device *dev,
+18 -20
drivers/rtc/rtc-vr41xx.c
··· 240 240 static int vr41xx_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 241 241 { 242 242 switch (cmd) { 243 - case RTC_AIE_ON: 244 - spin_lock_irq(&rtc_lock); 245 - 246 - if (!alarm_enabled) { 247 - enable_irq(aie_irq); 248 - alarm_enabled = 1; 249 - } 250 - 251 - spin_unlock_irq(&rtc_lock); 252 - break; 253 - case RTC_AIE_OFF: 254 - spin_lock_irq(&rtc_lock); 255 - 256 - if (alarm_enabled) { 257 - disable_irq(aie_irq); 258 - alarm_enabled = 0; 259 - } 260 - 261 - spin_unlock_irq(&rtc_lock); 262 - break; 263 243 case RTC_EPOCH_READ: 264 244 return put_user(epoch, (unsigned long __user *)arg); 265 245 case RTC_EPOCH_SET: ··· 252 272 return -ENOIOCTLCMD; 253 273 } 254 274 275 + return 0; 276 + } 277 + 278 + static int vr41xx_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 279 + { 280 + spin_lock_irq(&rtc_lock); 281 + if (enabled) { 282 + if (!alarm_enabled) { 283 + enable_irq(aie_irq); 284 + alarm_enabled = 1; 285 + } 286 + } else { 287 + if (alarm_enabled) { 288 + disable_irq(aie_irq); 289 + alarm_enabled = 0; 290 + } 291 + } 292 + spin_unlock_irq(&rtc_lock); 255 293 return 0; 256 294 } 257 295