mirror of
https://github.com/team-infusion-developers/android_kernel_samsung_msm8976.git
synced 2024-10-31 18:09:19 +00:00
Merge branch 'akpm' (incoming from Andrew)
Merge second batch of fixes from Andrew Morton: - various misc bits - some printk updates - a new "SRAM" driver. - MAINTAINERS updates - the backlight driver queue - checkpatch updates - a few init/ changes - a huge number of drivers/rtc changes - fatfs updates - some lib/idr.c work - some renaming of the random driver interfaces * emailed patches from Andrew Morton <akpm@linux-foundation.org>: (285 commits) net: rename random32 to prandom net/core: remove duplicate statements by do-while loop net/core: rename random32() to prandom_u32() net/netfilter: rename random32() to prandom_u32() net/sched: rename random32() to prandom_u32() net/sunrpc: rename random32() to prandom_u32() scsi: rename random32() to prandom_u32() lguest: rename random32() to prandom_u32() uwb: rename random32() to prandom_u32() video/uvesafb: rename random32() to prandom_u32() mmc: rename random32() to prandom_u32() drbd: rename random32() to prandom_u32() kernel/: rename random32() to prandom_u32() mm/: rename random32() to prandom_u32() lib/: rename random32() to prandom_u32() x86: rename random32() to prandom_u32() x86: pageattr-test: remove srandom32 call uuid: use prandom_bytes() raid6test: use prandom_bytes() sctp: convert sctp_assoc_set_id() to use idr_alloc_cyclic() ...
This commit is contained in:
commit
56847d857c
218 changed files with 2864 additions and 2308 deletions
4
CREDITS
4
CREDITS
|
@ -761,6 +761,10 @@ S: Northampton
|
|||
S: NN1 3QT
|
||||
S: United Kingdom
|
||||
|
||||
N: Massimo Dal Zotto
|
||||
E: dz@debian.org
|
||||
D: i8k Dell laptop SMM driver
|
||||
|
||||
N: Uwe Dannowski
|
||||
E: Uwe.Dannowski@ira.uka.de
|
||||
W: http://i30www.ira.uka.de/~dannowsk/
|
||||
|
|
|
@ -420,7 +420,7 @@ person it names. This tag documents that potentially interested parties
|
|||
have been included in the discussion
|
||||
|
||||
|
||||
14) Using Reported-by:, Tested-by: and Reviewed-by:
|
||||
14) Using Reported-by:, Tested-by:, Reviewed-by: and Suggested-by:
|
||||
|
||||
If this patch fixes a problem reported by somebody else, consider adding a
|
||||
Reported-by: tag to credit the reporter for their contribution. Please
|
||||
|
@ -468,6 +468,13 @@ done on the patch. Reviewed-by: tags, when supplied by reviewers known to
|
|||
understand the subject area and to perform thorough reviews, will normally
|
||||
increase the likelihood of your patch getting into the kernel.
|
||||
|
||||
A Suggested-by: tag indicates that the patch idea is suggested by the person
|
||||
named and ensures credit to the person for the idea. Please note that this
|
||||
tag should not be added without the reporter's permission, especially if the
|
||||
idea was not posted in a public forum. That said, if we diligently credit our
|
||||
idea reporters, they will, hopefully, be inspired to help us again in the
|
||||
future.
|
||||
|
||||
|
||||
15) The canonical patch format
|
||||
|
||||
|
|
|
@ -32,14 +32,10 @@ Platform data for lp855x
|
|||
For supporting platform specific data, the lp855x platform data can be used.
|
||||
|
||||
* name : Backlight driver name. If it is not defined, default name is set.
|
||||
* mode : Brightness control mode. PWM or register based.
|
||||
* device_control : Value of DEVICE CONTROL register.
|
||||
* initial_brightness : Initial value of backlight brightness.
|
||||
* period_ns : Platform specific PWM period value. unit is nano.
|
||||
Only valid when brightness is pwm input mode.
|
||||
* load_new_rom_data :
|
||||
0 : use default configuration data
|
||||
1 : update values of eeprom or eprom registers on loading driver
|
||||
* size_program : Total size of lp855x_rom_data.
|
||||
* rom_data : List of new eeprom/eprom registers.
|
||||
|
||||
|
@ -54,10 +50,8 @@ static struct lp855x_rom_data lp8552_eeprom_arr[] = {
|
|||
|
||||
static struct lp855x_platform_data lp8552_pdata = {
|
||||
.name = "lcd-bl",
|
||||
.mode = REGISTER_BASED,
|
||||
.device_control = I2C_CONFIG(LP8552),
|
||||
.initial_brightness = INITIAL_BRT,
|
||||
.load_new_rom_data = 1,
|
||||
.size_program = ARRAY_SIZE(lp8552_eeprom_arr),
|
||||
.rom_data = lp8552_eeprom_arr,
|
||||
};
|
||||
|
@ -65,7 +59,6 @@ static struct lp855x_platform_data lp8552_pdata = {
|
|||
example 2) lp8556 platform data : pwm input mode with default rom data
|
||||
|
||||
static struct lp855x_platform_data lp8556_pdata = {
|
||||
.mode = PWM_BASED,
|
||||
.device_control = PWM_CONFIG(LP8556),
|
||||
.initial_brightness = INITIAL_BRT,
|
||||
.period_ns = 1000000,
|
||||
|
|
30
Documentation/devicetree/bindings/media/coda.txt
Normal file
30
Documentation/devicetree/bindings/media/coda.txt
Normal file
|
@ -0,0 +1,30 @@
|
|||
Chips&Media Coda multi-standard codec IP
|
||||
========================================
|
||||
|
||||
Coda codec IPs are present in i.MX SoCs in various versions,
|
||||
called VPU (Video Processing Unit).
|
||||
|
||||
Required properties:
|
||||
- compatible : should be "fsl,<chip>-src" for i.MX SoCs:
|
||||
(a) "fsl,imx27-vpu" for CodaDx6 present in i.MX27
|
||||
(b) "fsl,imx53-vpu" for CODA7541 present in i.MX53
|
||||
(c) "fsl,imx6q-vpu" for CODA960 present in i.MX6q
|
||||
- reg: should be register base and length as documented in the
|
||||
SoC reference manual
|
||||
- interrupts : Should contain the VPU interrupt. For CODA960,
|
||||
a second interrupt is needed for the MJPEG unit.
|
||||
- clocks : Should contain the ahb and per clocks, in the order
|
||||
determined by the clock-names property.
|
||||
- clock-names : Should be "ahb", "per"
|
||||
- iram : phandle pointing to the SRAM device node
|
||||
|
||||
Example:
|
||||
|
||||
vpu: vpu@63ff4000 {
|
||||
compatible = "fsl,imx53-vpu";
|
||||
reg = <0x63ff4000 0x1000>;
|
||||
interrupts = <9>;
|
||||
clocks = <&clks 63>, <&clks 63>;
|
||||
clock-names = "ahb", "per";
|
||||
iram = <&ocram>;
|
||||
};
|
16
Documentation/devicetree/bindings/misc/sram.txt
Normal file
16
Documentation/devicetree/bindings/misc/sram.txt
Normal file
|
@ -0,0 +1,16 @@
|
|||
Generic on-chip SRAM
|
||||
|
||||
Simple IO memory regions to be managed by the genalloc API.
|
||||
|
||||
Required properties:
|
||||
|
||||
- compatible : mmio-sram
|
||||
|
||||
- reg : SRAM iomem address range
|
||||
|
||||
Example:
|
||||
|
||||
sram: sram@5c000000 {
|
||||
compatible = "mmio-sram";
|
||||
reg = <0x5c000000 0x40000>; /* 256 KiB SRAM at address 0x5c000000 */
|
||||
};
|
|
@ -0,0 +1,15 @@
|
|||
Atmel AT91RM9200 Real Time Clock
|
||||
|
||||
Required properties:
|
||||
- compatible: should be: "atmel,at91rm9200-rtc"
|
||||
- reg: physical base address of the controller and length of memory mapped
|
||||
region.
|
||||
- interrupts: rtc alarm/event interrupt
|
||||
|
||||
Example:
|
||||
|
||||
rtc@fffffe00 {
|
||||
compatible = "atmel,at91rm9200-rtc";
|
||||
reg = <0xfffffe00 0x100>;
|
||||
interrupts = <1 4 7>;
|
||||
};
|
41
Documentation/devicetree/bindings/video/backlight/lp855x.txt
Normal file
41
Documentation/devicetree/bindings/video/backlight/lp855x.txt
Normal file
|
@ -0,0 +1,41 @@
|
|||
lp855x bindings
|
||||
|
||||
Required properties:
|
||||
- compatible: "ti,lp8550", "ti,lp8551", "ti,lp8552", "ti,lp8553",
|
||||
"ti,lp8556", "ti,lp8557"
|
||||
- reg: I2C slave address (u8)
|
||||
- dev-ctrl: Value of DEVICE CONTROL register (u8). It depends on the device.
|
||||
|
||||
Optional properties:
|
||||
- bl-name: Backlight device name (string)
|
||||
- init-brt: Initial value of backlight brightness (u8)
|
||||
- pwm-period: PWM period value. Set only PWM input mode used (u32)
|
||||
- rom-addr: Register address of ROM area to be updated (u8)
|
||||
- rom-val: Register value to be updated (u8)
|
||||
|
||||
Example:
|
||||
|
||||
/* LP8556 */
|
||||
backlight@2c {
|
||||
compatible = "ti,lp8556";
|
||||
reg = <0x2c>;
|
||||
|
||||
bl-name = "lcd-bl";
|
||||
dev-ctrl = /bits/ 8 <0x85>;
|
||||
init-brt = /bits/ 8 <0x10>;
|
||||
};
|
||||
|
||||
/* LP8557 */
|
||||
backlight@2c {
|
||||
compatible = "ti,lp8557";
|
||||
reg = <0x2c>;
|
||||
|
||||
dev-ctrl = /bits/ 8 <0x41>;
|
||||
init-brt = /bits/ 8 <0x0a>;
|
||||
|
||||
/* 4V OV, 4 output LED string enabled */
|
||||
rom_14h {
|
||||
rom-addr = /bits/ 8 <0x14>;
|
||||
rom-val = /bits/ 8 <0xcf>;
|
||||
};
|
||||
};
|
|
@ -0,0 +1,27 @@
|
|||
TPS65217 family of regulators
|
||||
|
||||
The TPS65217 chip contains a boost converter and current sinks which can be
|
||||
used to drive LEDs for use as backlights.
|
||||
|
||||
Required properties:
|
||||
- compatible: "ti,tps65217"
|
||||
- reg: I2C slave address
|
||||
- backlight: node for specifying WLED1 and WLED2 lines in TPS65217
|
||||
- isel: selection bit, valid values: 1 for ISEL1 (low-level) and 2 for ISEL2 (high-level)
|
||||
- fdim: PWM dimming frequency, valid values: 100, 200, 500, 1000
|
||||
- default-brightness: valid values: 0-100
|
||||
|
||||
Each regulator is defined using the standard binding for regulators.
|
||||
|
||||
Example:
|
||||
|
||||
tps: tps@24 {
|
||||
reg = <0x24>;
|
||||
compatible = "ti,tps65217";
|
||||
backlight {
|
||||
isel = <1>; /* 1 - ISET1, 2 ISET2 */
|
||||
fdim = <100>; /* TPS65217_BL_FDIM_100HZ */
|
||||
default-brightness = <50>;
|
||||
};
|
||||
};
|
||||
|
|
@ -150,12 +150,28 @@ discard -- If set, issues discard/TRIM commands to the block
|
|||
device when blocks are freed. This is useful for SSD devices
|
||||
and sparse/thinly-provisoned LUNs.
|
||||
|
||||
nfs -- This option maintains an index (cache) of directory
|
||||
inodes by i_logstart which is used by the nfs-related code to
|
||||
improve look-ups.
|
||||
nfs=stale_rw|nostale_ro
|
||||
Enable this only if you want to export the FAT filesystem
|
||||
over NFS.
|
||||
|
||||
stale_rw: This option maintains an index (cache) of directory
|
||||
inodes by i_logstart which is used by the nfs-related code to
|
||||
improve look-ups. Full file operations (read/write) over NFS is
|
||||
supported but with cache eviction at NFS server, this could
|
||||
result in ESTALE issues.
|
||||
|
||||
nostale_ro: This option bases the inode number and filehandle
|
||||
on the on-disk location of a file in the MS-DOS directory entry.
|
||||
This ensures that ESTALE will not be returned after a file is
|
||||
evicted from the inode cache. However, it means that operations
|
||||
such as rename, create and unlink could cause filehandles that
|
||||
previously pointed at one file to point at a different file,
|
||||
potentially causing data corruption. For this reason, this
|
||||
option also mounts the filesystem readonly.
|
||||
|
||||
To maintain backward compatibility, '-o nfs' is also accepted,
|
||||
defaulting to stale_rw
|
||||
|
||||
Enable this only if you want to export the FAT filesystem
|
||||
over NFS
|
||||
|
||||
<bool>: 0,1,yes,no,true,false
|
||||
|
||||
|
|
24
MAINTAINERS
24
MAINTAINERS
|
@ -90,6 +90,9 @@ Descriptions of section entries:
|
|||
F: drivers/net/* all files in drivers/net, but not below
|
||||
F: */net/* all files in "any top level directory"/net
|
||||
One pattern per line. Multiple F: lines acceptable.
|
||||
N: Files and directories with regex patterns.
|
||||
N: [^a-z]tegra all files whose path contains the word tegra
|
||||
One pattern per line. Multiple N: lines acceptable.
|
||||
X: Files and directories that are NOT maintained, same rules as F:
|
||||
Files exclusions are tested before file matches.
|
||||
Can be useful for excluding a specific subdirectory, for instance:
|
||||
|
@ -97,13 +100,12 @@ Descriptions of section entries:
|
|||
X: net/ipv6/
|
||||
matches all files in and below net excluding net/ipv6/
|
||||
K: Keyword perl extended regex pattern to match content in a
|
||||
patch or file, or an affected filename. For instance:
|
||||
patch or file. For instance:
|
||||
K: of_get_profile
|
||||
matches patch or file content, or filenames, that contain
|
||||
"of_get_profile"
|
||||
matches patches or files that contain "of_get_profile"
|
||||
K: \b(printk|pr_(info|err))\b
|
||||
matches patch or file content, or filenames, that contain one or
|
||||
more of the words printk, pr_info or pr_err
|
||||
matches patches or files that contain one or more of the words
|
||||
printk, pr_info or pr_err
|
||||
One regex pattern per line. Multiple K: lines acceptable.
|
||||
|
||||
Note: For the hard of thinking, this list is meant to remain in alphabetical
|
||||
|
@ -2442,9 +2444,7 @@ S: Maintained
|
|||
F: drivers/platform/x86/dell-laptop.c
|
||||
|
||||
DELL LAPTOP SMM DRIVER
|
||||
M: Massimo Dal Zotto <dz@debian.org>
|
||||
W: http://www.debian.org/~dz/i8k/
|
||||
S: Maintained
|
||||
S: Orphan
|
||||
F: drivers/char/i8k.c
|
||||
F: include/uapi/linux/i8k.h
|
||||
|
||||
|
@ -7893,7 +7893,7 @@ L: linux-tegra@vger.kernel.org
|
|||
Q: http://patchwork.ozlabs.org/project/linux-tegra/list/
|
||||
T: git git://git.kernel.org/pub/scm/linux/kernel/git/swarren/linux-tegra.git
|
||||
S: Supported
|
||||
K: (?i)[^a-z]tegra
|
||||
N: [^a-z]tegra
|
||||
|
||||
TEHUTI ETHERNET DRIVER
|
||||
M: Andy Gospodarek <andy@greyhouse.net>
|
||||
|
@ -8379,9 +8379,10 @@ S: Maintained
|
|||
F: drivers/usb/serial/option.c
|
||||
|
||||
USB PEGASUS DRIVER
|
||||
M: Petko Manolov <petkan@users.sourceforge.net>
|
||||
M: Petko Manolov <petkan@nucleusys.com>
|
||||
L: linux-usb@vger.kernel.org
|
||||
L: netdev@vger.kernel.org
|
||||
T: git git://git.code.sf.net/p/pegasus2/git
|
||||
W: http://pegasus2.sourceforge.net/
|
||||
S: Maintained
|
||||
F: drivers/net/usb/pegasus.*
|
||||
|
@ -8401,9 +8402,10 @@ S: Supported
|
|||
F: drivers/usb/class/usblp.c
|
||||
|
||||
USB RTL8150 DRIVER
|
||||
M: Petko Manolov <petkan@users.sourceforge.net>
|
||||
M: Petko Manolov <petkan@nucleusys.com>
|
||||
L: linux-usb@vger.kernel.org
|
||||
L: netdev@vger.kernel.org
|
||||
T: git git://git.code.sf.net/p/pegasus2/git
|
||||
W: http://pegasus2.sourceforge.net/
|
||||
S: Maintained
|
||||
F: drivers/net/usb/rtl8150.c
|
||||
|
|
|
@ -29,28 +29,17 @@ static void early_console_write(struct console *con, const char *s, unsigned n)
|
|||
early_write(s, n);
|
||||
}
|
||||
|
||||
static struct console early_console = {
|
||||
static struct console early_console_dev = {
|
||||
.name = "earlycon",
|
||||
.write = early_console_write,
|
||||
.flags = CON_PRINTBUFFER | CON_BOOT,
|
||||
.index = -1,
|
||||
};
|
||||
|
||||
asmlinkage void early_printk(const char *fmt, ...)
|
||||
{
|
||||
char buf[512];
|
||||
int n;
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
n = vscnprintf(buf, sizeof(buf), fmt, ap);
|
||||
early_write(buf, n);
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
static int __init setup_early_printk(char *buf)
|
||||
{
|
||||
register_console(&early_console);
|
||||
early_console = &early_console_dev;
|
||||
register_console(&early_console_dev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -25,8 +25,6 @@ extern struct console *bfin_earlyserial_init(unsigned int port,
|
|||
extern struct console *bfin_jc_early_init(void);
|
||||
#endif
|
||||
|
||||
static struct console *early_console;
|
||||
|
||||
/* Default console */
|
||||
#define DEFAULT_PORT 0
|
||||
#define DEFAULT_CFLAG CS8|B57600
|
||||
|
|
|
@ -21,7 +21,6 @@
|
|||
#include <asm/setup.h>
|
||||
#include <asm/prom.h>
|
||||
|
||||
static u32 early_console_initialized;
|
||||
static u32 base_addr;
|
||||
|
||||
#ifdef CONFIG_SERIAL_UARTLITE_CONSOLE
|
||||
|
@ -109,27 +108,11 @@ static struct console early_serial_uart16550_console = {
|
|||
};
|
||||
#endif /* CONFIG_SERIAL_8250_CONSOLE */
|
||||
|
||||
static struct console *early_console;
|
||||
|
||||
void early_printk(const char *fmt, ...)
|
||||
{
|
||||
char buf[512];
|
||||
int n;
|
||||
va_list ap;
|
||||
|
||||
if (early_console_initialized) {
|
||||
va_start(ap, fmt);
|
||||
n = vscnprintf(buf, 512, fmt, ap);
|
||||
early_console->write(early_console, buf, n);
|
||||
va_end(ap);
|
||||
}
|
||||
}
|
||||
|
||||
int __init setup_early_printk(char *opt)
|
||||
{
|
||||
int version = 0;
|
||||
|
||||
if (early_console_initialized)
|
||||
if (early_console)
|
||||
return 1;
|
||||
|
||||
base_addr = of_early_console(&version);
|
||||
|
@ -159,7 +142,6 @@ int __init setup_early_printk(char *opt)
|
|||
}
|
||||
|
||||
register_console(early_console);
|
||||
early_console_initialized = 1;
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
|
@ -169,7 +151,7 @@ int __init setup_early_printk(char *opt)
|
|||
* only for early console because of performance degression */
|
||||
void __init remap_early_printk(void)
|
||||
{
|
||||
if (!early_console_initialized || !early_console)
|
||||
if (!early_console)
|
||||
return;
|
||||
pr_info("early_printk_console remapping from 0x%x to ", base_addr);
|
||||
base_addr = (u32) ioremap(base_addr, PAGE_SIZE);
|
||||
|
@ -194,9 +176,9 @@ void __init remap_early_printk(void)
|
|||
|
||||
void __init disable_early_printk(void)
|
||||
{
|
||||
if (!early_console_initialized || !early_console)
|
||||
if (!early_console)
|
||||
return;
|
||||
pr_warn("disabling early console\n");
|
||||
unregister_console(early_console);
|
||||
early_console_initialized = 0;
|
||||
early_console = NULL;
|
||||
}
|
||||
|
|
|
@ -7,7 +7,9 @@
|
|||
* Copyright (C) 2007 MIPS Technologies, Inc.
|
||||
* written by Ralf Baechle (ralf@linux-mips.org)
|
||||
*/
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/console.h>
|
||||
#include <linux/printk.h>
|
||||
#include <linux/init.h>
|
||||
|
||||
#include <asm/setup.h>
|
||||
|
@ -24,20 +26,18 @@ static void early_console_write(struct console *con, const char *s, unsigned n)
|
|||
}
|
||||
}
|
||||
|
||||
static struct console early_console = {
|
||||
static struct console early_console_prom = {
|
||||
.name = "early",
|
||||
.write = early_console_write,
|
||||
.flags = CON_PRINTBUFFER | CON_BOOT,
|
||||
.index = -1
|
||||
};
|
||||
|
||||
static int early_console_initialized __initdata;
|
||||
|
||||
void __init setup_early_printk(void)
|
||||
{
|
||||
if (early_console_initialized)
|
||||
if (early_console)
|
||||
return;
|
||||
early_console_initialized = 1;
|
||||
early_console = &early_console_prom;
|
||||
|
||||
register_console(&early_console);
|
||||
register_console(&early_console_prom);
|
||||
}
|
||||
|
|
|
@ -156,15 +156,13 @@ static struct console udbg_console = {
|
|||
.index = 0,
|
||||
};
|
||||
|
||||
static int early_console_initialized;
|
||||
|
||||
/*
|
||||
* Called by setup_system after ppc_md->probe and ppc_md->early_init.
|
||||
* Call it again after setting udbg_putc in ppc_md->setup_arch.
|
||||
*/
|
||||
void __init register_early_udbg_console(void)
|
||||
{
|
||||
if (early_console_initialized)
|
||||
if (early_console)
|
||||
return;
|
||||
|
||||
if (!udbg_putc)
|
||||
|
@ -174,7 +172,7 @@ void __init register_early_udbg_console(void)
|
|||
printk(KERN_INFO "early console immortal !\n");
|
||||
udbg_console.flags &= ~CON_BOOT;
|
||||
}
|
||||
early_console_initialized = 1;
|
||||
early_console = &udbg_console;
|
||||
register_console(&udbg_console);
|
||||
}
|
||||
|
||||
|
|
|
@ -104,6 +104,7 @@ void sh_bios_vbr_reload(void)
|
|||
);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_EARLY_PRINTK
|
||||
/*
|
||||
* Print a string through the BIOS
|
||||
*/
|
||||
|
@ -144,8 +145,6 @@ static struct console bios_console = {
|
|||
.index = -1,
|
||||
};
|
||||
|
||||
static struct console *early_console;
|
||||
|
||||
static int __init setup_early_printk(char *buf)
|
||||
{
|
||||
int keep_early = 0;
|
||||
|
@ -170,3 +169,4 @@ static int __init setup_early_printk(char *buf)
|
|||
return 0;
|
||||
}
|
||||
early_param("earlyprintk", setup_early_printk);
|
||||
#endif
|
||||
|
|
|
@ -17,6 +17,7 @@
|
|||
#include <linux/init.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/irqflags.h>
|
||||
#include <linux/printk.h>
|
||||
#include <asm/setup.h>
|
||||
#include <hv/hypervisor.h>
|
||||
|
||||
|
@ -33,25 +34,8 @@ static struct console early_hv_console = {
|
|||
};
|
||||
|
||||
/* Direct interface for emergencies */
|
||||
static struct console *early_console = &early_hv_console;
|
||||
static int early_console_initialized;
|
||||
static int early_console_complete;
|
||||
|
||||
static void early_vprintk(const char *fmt, va_list ap)
|
||||
{
|
||||
char buf[512];
|
||||
int n = vscnprintf(buf, sizeof(buf), fmt, ap);
|
||||
early_console->write(early_console, buf, n);
|
||||
}
|
||||
|
||||
void early_printk(const char *fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
va_start(ap, fmt);
|
||||
early_vprintk(fmt, ap);
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
void early_panic(const char *fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
@ -69,14 +53,13 @@ static int __initdata keep_early;
|
|||
|
||||
static int __init setup_early_printk(char *str)
|
||||
{
|
||||
if (early_console_initialized)
|
||||
if (early_console)
|
||||
return 1;
|
||||
|
||||
if (str != NULL && strncmp(str, "keep", 4) == 0)
|
||||
keep_early = 1;
|
||||
|
||||
early_console = &early_hv_console;
|
||||
early_console_initialized = 1;
|
||||
register_console(early_console);
|
||||
|
||||
return 0;
|
||||
|
@ -85,12 +68,12 @@ static int __init setup_early_printk(char *str)
|
|||
void __init disable_early_printk(void)
|
||||
{
|
||||
early_console_complete = 1;
|
||||
if (!early_console_initialized || !early_console)
|
||||
if (!early_console)
|
||||
return;
|
||||
if (!keep_early) {
|
||||
early_printk("disabling early console\n");
|
||||
unregister_console(early_console);
|
||||
early_console_initialized = 0;
|
||||
early_console = NULL;
|
||||
} else {
|
||||
early_printk("keeping early console\n");
|
||||
}
|
||||
|
@ -98,7 +81,7 @@ void __init disable_early_printk(void)
|
|||
|
||||
void warn_early_printk(void)
|
||||
{
|
||||
if (early_console_complete || early_console_initialized)
|
||||
if (early_console_complete || early_console)
|
||||
return;
|
||||
early_printk("\
|
||||
Machine shutting down before console output is fully initialized.\n\
|
||||
|
|
|
@ -16,7 +16,7 @@ static void early_console_write(struct console *con, const char *s, unsigned int
|
|||
um_early_printk(s, n);
|
||||
}
|
||||
|
||||
static struct console early_console = {
|
||||
static struct console early_console_dev = {
|
||||
.name = "earlycon",
|
||||
.write = early_console_write,
|
||||
.flags = CON_BOOT,
|
||||
|
@ -25,8 +25,10 @@ static struct console early_console = {
|
|||
|
||||
static int __init setup_early_printk(char *buf)
|
||||
{
|
||||
register_console(&early_console);
|
||||
|
||||
if (!early_console) {
|
||||
early_console = &early_console_dev;
|
||||
register_console(&early_console_dev);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -33,21 +33,17 @@ static struct console early_ocd_console = {
|
|||
.index = -1,
|
||||
};
|
||||
|
||||
/* Direct interface for emergencies */
|
||||
static struct console *early_console = &early_ocd_console;
|
||||
|
||||
static int __initdata keep_early;
|
||||
|
||||
static int __init setup_early_printk(char *buf)
|
||||
{
|
||||
if (!buf)
|
||||
int keep_early;
|
||||
|
||||
if (!buf || early_console)
|
||||
return 0;
|
||||
|
||||
if (strstr(buf, "keep"))
|
||||
keep_early = 1;
|
||||
|
||||
if (!strncmp(buf, "ocd", 3))
|
||||
early_console = &early_ocd_console;
|
||||
early_console = &early_ocd_console;
|
||||
|
||||
if (keep_early)
|
||||
early_console->flags &= ~CON_BOOT;
|
||||
|
|
|
@ -169,25 +169,9 @@ static struct console early_serial_console = {
|
|||
.index = -1,
|
||||
};
|
||||
|
||||
/* Direct interface for emergencies */
|
||||
static struct console *early_console = &early_vga_console;
|
||||
static int __initdata early_console_initialized;
|
||||
|
||||
asmlinkage void early_printk(const char *fmt, ...)
|
||||
{
|
||||
char buf[512];
|
||||
int n;
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
n = vscnprintf(buf, sizeof(buf), fmt, ap);
|
||||
early_console->write(early_console, buf, n);
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
static inline void early_console_register(struct console *con, int keep_early)
|
||||
{
|
||||
if (early_console->index != -1) {
|
||||
if (con->index != -1) {
|
||||
printk(KERN_CRIT "ERROR: earlyprintk= %s already used\n",
|
||||
con->name);
|
||||
return;
|
||||
|
@ -207,9 +191,8 @@ static int __init setup_early_printk(char *buf)
|
|||
if (!buf)
|
||||
return 0;
|
||||
|
||||
if (early_console_initialized)
|
||||
if (early_console)
|
||||
return 0;
|
||||
early_console_initialized = 1;
|
||||
|
||||
keep = (strstr(buf, "keep") != NULL);
|
||||
|
||||
|
|
|
@ -130,13 +130,12 @@ static int pageattr_test(void)
|
|||
}
|
||||
|
||||
failed += print_split(&sa);
|
||||
srandom32(100);
|
||||
|
||||
for (i = 0; i < NTEST; i++) {
|
||||
unsigned long pfn = random32() % max_pfn_mapped;
|
||||
unsigned long pfn = prandom_u32() % max_pfn_mapped;
|
||||
|
||||
addr[i] = (unsigned long)__va(pfn << PAGE_SHIFT);
|
||||
len[i] = random32() % 100;
|
||||
len[i] = prandom_u32() % 100;
|
||||
len[i] = min_t(unsigned long, len[i], max_pfn_mapped - pfn - 1);
|
||||
|
||||
if (len[i] == 0)
|
||||
|
|
|
@ -46,15 +46,10 @@ static void callback(void *param)
|
|||
|
||||
static void makedata(int disks)
|
||||
{
|
||||
int i, j;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < disks; i++) {
|
||||
for (j = 0; j < PAGE_SIZE/sizeof(u32); j += sizeof(u32)) {
|
||||
u32 *p = page_address(data[i]) + j;
|
||||
|
||||
*p = random32();
|
||||
}
|
||||
|
||||
prandom_bytes(page_address(data[i]), PAGE_SIZE);
|
||||
dataptrs[i] = data[i];
|
||||
}
|
||||
}
|
||||
|
|
|
@ -757,7 +757,8 @@ static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn, struct acc
|
|||
rcu_read_unlock();
|
||||
|
||||
timeo = connect_int * HZ;
|
||||
timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */
|
||||
/* 28.5% random jitter */
|
||||
timeo += (prandom_u32() & 1) ? timeo / 7 : -timeo / 7;
|
||||
|
||||
err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo);
|
||||
if (err <= 0)
|
||||
|
@ -953,7 +954,7 @@ retry:
|
|||
conn_warn(tconn, "Error receiving initial packet\n");
|
||||
sock_release(s);
|
||||
randomize:
|
||||
if (random32() & 1)
|
||||
if (prandom_u32() & 1)
|
||||
goto retry;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -265,7 +265,6 @@ struct c2_pd_table {
|
|||
struct c2_qp_table {
|
||||
struct idr idr;
|
||||
spinlock_t lock;
|
||||
int last;
|
||||
};
|
||||
|
||||
struct c2_element {
|
||||
|
|
|
@ -385,8 +385,7 @@ static int c2_alloc_qpn(struct c2_dev *c2dev, struct c2_qp *qp)
|
|||
idr_preload(GFP_KERNEL);
|
||||
spin_lock_irq(&c2dev->qp_table.lock);
|
||||
|
||||
ret = idr_alloc(&c2dev->qp_table.idr, qp, c2dev->qp_table.last++, 0,
|
||||
GFP_NOWAIT);
|
||||
ret = idr_alloc_cyclic(&c2dev->qp_table.idr, qp, 0, 0, GFP_NOWAIT);
|
||||
if (ret >= 0)
|
||||
qp->qpn = ret;
|
||||
|
||||
|
|
|
@ -204,7 +204,6 @@ static struct id_map_entry *
|
|||
id_map_alloc(struct ib_device *ibdev, int slave_id, u32 sl_cm_id)
|
||||
{
|
||||
int ret;
|
||||
static int next_id;
|
||||
struct id_map_entry *ent;
|
||||
struct mlx4_ib_sriov *sriov = &to_mdev(ibdev)->sriov;
|
||||
|
||||
|
@ -223,9 +222,8 @@ id_map_alloc(struct ib_device *ibdev, int slave_id, u32 sl_cm_id)
|
|||
idr_preload(GFP_KERNEL);
|
||||
spin_lock(&to_mdev(ibdev)->sriov.id_map_lock);
|
||||
|
||||
ret = idr_alloc(&sriov->pv_id_table, ent, next_id, 0, GFP_NOWAIT);
|
||||
ret = idr_alloc_cyclic(&sriov->pv_id_table, ent, 0, 0, GFP_NOWAIT);
|
||||
if (ret >= 0) {
|
||||
next_id = max(ret + 1, 0);
|
||||
ent->pv_cm_id = (u32)ret;
|
||||
sl_id_map_add(ibdev, ent);
|
||||
list_add_tail(&ent->list, &sriov->cm_list);
|
||||
|
|
|
@ -686,7 +686,7 @@ static unsigned int new_pgdir(struct lg_cpu *cpu,
|
|||
* We pick one entry at random to throw out. Choosing the Least
|
||||
* Recently Used might be better, but this is easy.
|
||||
*/
|
||||
next = random32() % ARRAY_SIZE(cpu->lg->pgdirs);
|
||||
next = prandom_u32() % ARRAY_SIZE(cpu->lg->pgdirs);
|
||||
/* If it's never been allocated at all before, try now. */
|
||||
if (!cpu->lg->pgdirs[next].pgdir) {
|
||||
cpu->lg->pgdirs[next].pgdir =
|
||||
|
|
|
@ -145,7 +145,6 @@ config VIDEO_CODA
|
|||
depends on VIDEO_DEV && VIDEO_V4L2 && ARCH_MXC
|
||||
select VIDEOBUF2_DMA_CONTIG
|
||||
select V4L2_MEM2MEM_DEV
|
||||
select IRAM_ALLOC if SOC_IMX53
|
||||
---help---
|
||||
Coda is a range of video codec IPs that supports
|
||||
H.264, MPEG-4, and other video formats.
|
||||
|
|
|
@ -14,6 +14,7 @@
|
|||
#include <linux/clk.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/firmware.h>
|
||||
#include <linux/genalloc.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/irq.h>
|
||||
|
@ -23,7 +24,7 @@
|
|||
#include <linux/slab.h>
|
||||
#include <linux/videodev2.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/platform_data/imx-iram.h>
|
||||
#include <linux/platform_data/coda.h>
|
||||
|
||||
#include <media/v4l2-ctrls.h>
|
||||
#include <media/v4l2-device.h>
|
||||
|
@ -43,6 +44,7 @@
|
|||
#define CODA7_WORK_BUF_SIZE (512 * 1024 + CODA_FMO_BUF_SIZE * 8 * 1024)
|
||||
#define CODA_PARA_BUF_SIZE (10 * 1024)
|
||||
#define CODA_ISRAM_SIZE (2048 * 2)
|
||||
#define CODADX6_IRAM_SIZE 0xb000
|
||||
#define CODA7_IRAM_SIZE 0x14000 /* 81920 bytes */
|
||||
|
||||
#define CODA_MAX_FRAMEBUFFERS 2
|
||||
|
@ -128,7 +130,10 @@ struct coda_dev {
|
|||
|
||||
struct coda_aux_buf codebuf;
|
||||
struct coda_aux_buf workbuf;
|
||||
struct gen_pool *iram_pool;
|
||||
long unsigned int iram_vaddr;
|
||||
long unsigned int iram_paddr;
|
||||
unsigned long iram_size;
|
||||
|
||||
spinlock_t irqlock;
|
||||
struct mutex dev_mutex;
|
||||
|
@ -1926,6 +1931,9 @@ static int coda_probe(struct platform_device *pdev)
|
|||
const struct of_device_id *of_id =
|
||||
of_match_device(of_match_ptr(coda_dt_ids), &pdev->dev);
|
||||
const struct platform_device_id *pdev_id;
|
||||
struct coda_platform_data *pdata = pdev->dev.platform_data;
|
||||
struct device_node *np = pdev->dev.of_node;
|
||||
struct gen_pool *pool;
|
||||
struct coda_dev *dev;
|
||||
struct resource *res;
|
||||
int ret, irq;
|
||||
|
@ -1988,6 +1996,16 @@ static int coda_probe(struct platform_device *pdev)
|
|||
return -ENOENT;
|
||||
}
|
||||
|
||||
/* Get IRAM pool from device tree or platform data */
|
||||
pool = of_get_named_gen_pool(np, "iram", 0);
|
||||
if (!pool && pdata)
|
||||
pool = dev_get_gen_pool(pdata->iram_dev);
|
||||
if (!pool) {
|
||||
dev_err(&pdev->dev, "iram pool not available\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
dev->iram_pool = pool;
|
||||
|
||||
ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
@ -2022,18 +2040,17 @@ static int coda_probe(struct platform_device *pdev)
|
|||
return -ENOMEM;
|
||||
}
|
||||
|
||||
if (dev->devtype->product == CODA_DX6) {
|
||||
dev->iram_paddr = 0xffff4c00;
|
||||
} else {
|
||||
void __iomem *iram_vaddr;
|
||||
|
||||
iram_vaddr = iram_alloc(CODA7_IRAM_SIZE,
|
||||
&dev->iram_paddr);
|
||||
if (!iram_vaddr) {
|
||||
dev_err(&pdev->dev, "unable to alloc iram\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
if (dev->devtype->product == CODA_DX6)
|
||||
dev->iram_size = CODADX6_IRAM_SIZE;
|
||||
else
|
||||
dev->iram_size = CODA7_IRAM_SIZE;
|
||||
dev->iram_vaddr = gen_pool_alloc(dev->iram_pool, dev->iram_size);
|
||||
if (!dev->iram_vaddr) {
|
||||
dev_err(&pdev->dev, "unable to alloc iram\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
dev->iram_paddr = gen_pool_virt_to_phys(dev->iram_pool,
|
||||
dev->iram_vaddr);
|
||||
|
||||
platform_set_drvdata(pdev, dev);
|
||||
|
||||
|
@ -2050,8 +2067,8 @@ static int coda_remove(struct platform_device *pdev)
|
|||
if (dev->alloc_ctx)
|
||||
vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);
|
||||
v4l2_device_unregister(&dev->v4l2_dev);
|
||||
if (dev->iram_paddr)
|
||||
iram_free(dev->iram_paddr, CODA7_IRAM_SIZE);
|
||||
if (dev->iram_vaddr)
|
||||
gen_pool_free(dev->iram_pool, dev->iram_vaddr, dev->iram_size);
|
||||
if (dev->codebuf.vaddr)
|
||||
dma_free_coherent(&pdev->dev, dev->codebuf.size,
|
||||
&dev->codebuf.vaddr, dev->codebuf.paddr);
|
||||
|
|
|
@ -518,6 +518,15 @@ config LATTICE_ECP3_CONFIG
|
|||
|
||||
If unsure, say N.
|
||||
|
||||
config SRAM
|
||||
bool "Generic on-chip SRAM driver"
|
||||
depends on HAS_IOMEM
|
||||
select GENERIC_ALLOCATOR
|
||||
help
|
||||
This driver allows you to declare a memory region to be managed by
|
||||
the genalloc API. It is supposed to be used for small on-chip SRAM
|
||||
areas found on many SoCs.
|
||||
|
||||
source "drivers/misc/c2port/Kconfig"
|
||||
source "drivers/misc/eeprom/Kconfig"
|
||||
source "drivers/misc/cb710/Kconfig"
|
||||
|
|
|
@ -52,3 +52,4 @@ obj-$(CONFIG_ALTERA_STAPL) +=altera-stapl/
|
|||
obj-$(CONFIG_INTEL_MEI) += mei/
|
||||
obj-$(CONFIG_VMWARE_VMCI) += vmw_vmci/
|
||||
obj-$(CONFIG_LATTICE_ECP3_CONFIG) += lattice-ecp3-config.o
|
||||
obj-$(CONFIG_SRAM) += sram.o
|
||||
|
|
121
drivers/misc/sram.c
Normal file
121
drivers/misc/sram.c
Normal file
|
@ -0,0 +1,121 @@
|
|||
/*
|
||||
* Generic on-chip SRAM allocation driver
|
||||
*
|
||||
* Copyright (C) 2012 Philipp Zabel, Pengutronix
|
||||
*
|
||||
* 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 program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* 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., 51 Franklin Street, Fifth Floor, Boston,
|
||||
* MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/clk.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/genalloc.h>
|
||||
|
||||
#define SRAM_GRANULARITY 32
|
||||
|
||||
struct sram_dev {
|
||||
struct gen_pool *pool;
|
||||
struct clk *clk;
|
||||
};
|
||||
|
||||
static int sram_probe(struct platform_device *pdev)
|
||||
{
|
||||
void __iomem *virt_base;
|
||||
struct sram_dev *sram;
|
||||
struct resource *res;
|
||||
unsigned long size;
|
||||
int ret;
|
||||
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
if (!res)
|
||||
return -EINVAL;
|
||||
|
||||
size = resource_size(res);
|
||||
|
||||
virt_base = devm_request_and_ioremap(&pdev->dev, res);
|
||||
if (!virt_base)
|
||||
return -EADDRNOTAVAIL;
|
||||
|
||||
sram = devm_kzalloc(&pdev->dev, sizeof(*sram), GFP_KERNEL);
|
||||
if (!sram)
|
||||
return -ENOMEM;
|
||||
|
||||
sram->clk = devm_clk_get(&pdev->dev, NULL);
|
||||
if (IS_ERR(sram->clk))
|
||||
sram->clk = NULL;
|
||||
else
|
||||
clk_prepare_enable(sram->clk);
|
||||
|
||||
sram->pool = devm_gen_pool_create(&pdev->dev, ilog2(SRAM_GRANULARITY), -1);
|
||||
if (!sram->pool)
|
||||
return -ENOMEM;
|
||||
|
||||
ret = gen_pool_add_virt(sram->pool, (unsigned long)virt_base,
|
||||
res->start, size, -1);
|
||||
if (ret < 0) {
|
||||
gen_pool_destroy(sram->pool);
|
||||
return ret;
|
||||
}
|
||||
|
||||
platform_set_drvdata(pdev, sram);
|
||||
|
||||
dev_dbg(&pdev->dev, "SRAM pool: %ld KiB @ 0x%p\n", size / 1024, virt_base);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sram_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct sram_dev *sram = platform_get_drvdata(pdev);
|
||||
|
||||
if (gen_pool_avail(sram->pool) < gen_pool_size(sram->pool))
|
||||
dev_dbg(&pdev->dev, "removed while SRAM allocated\n");
|
||||
|
||||
gen_pool_destroy(sram->pool);
|
||||
|
||||
if (sram->clk)
|
||||
clk_disable_unprepare(sram->clk);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_OF
|
||||
static struct of_device_id sram_dt_ids[] = {
|
||||
{ .compatible = "mmio-sram" },
|
||||
{}
|
||||
};
|
||||
#endif
|
||||
|
||||
static struct platform_driver sram_driver = {
|
||||
.driver = {
|
||||
.name = "sram",
|
||||
.of_match_table = of_match_ptr(sram_dt_ids),
|
||||
},
|
||||
.probe = sram_probe,
|
||||
.remove = sram_remove,
|
||||
};
|
||||
|
||||
static int __init sram_init(void)
|
||||
{
|
||||
return platform_driver_register(&sram_driver);
|
||||
}
|
||||
|
||||
postcore_initcall(sram_init);
|
|
@ -120,8 +120,8 @@ static void mmc_should_fail_request(struct mmc_host *host,
|
|||
!should_fail(&host->fail_mmc_request, data->blksz * data->blocks))
|
||||
return;
|
||||
|
||||
data->error = data_errors[random32() % ARRAY_SIZE(data_errors)];
|
||||
data->bytes_xfered = (random32() % (data->bytes_xfered >> 9)) << 9;
|
||||
data->error = data_errors[prandom_u32() % ARRAY_SIZE(data_errors)];
|
||||
data->bytes_xfered = (prandom_u32() % (data->bytes_xfered >> 9)) << 9;
|
||||
}
|
||||
|
||||
#else /* CONFIG_FAIL_MMC_REQUEST */
|
||||
|
|
|
@ -951,8 +951,10 @@ static int rpmsg_probe(struct virtio_device *vdev)
|
|||
bufs_va = dma_alloc_coherent(vdev->dev.parent->parent,
|
||||
RPMSG_TOTAL_BUF_SPACE,
|
||||
&vrp->bufs_dma, GFP_KERNEL);
|
||||
if (!bufs_va)
|
||||
if (!bufs_va) {
|
||||
err = -ENOMEM;
|
||||
goto vqs_del;
|
||||
}
|
||||
|
||||
dev_dbg(&vdev->dev, "buffers: va %p, dma 0x%llx\n", bufs_va,
|
||||
(unsigned long long)vrp->bufs_dma);
|
||||
|
|
|
@ -259,6 +259,76 @@ void rtc_device_unregister(struct rtc_device *rtc)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(rtc_device_unregister);
|
||||
|
||||
static void devm_rtc_device_release(struct device *dev, void *res)
|
||||
{
|
||||
struct rtc_device *rtc = *(struct rtc_device **)res;
|
||||
|
||||
rtc_device_unregister(rtc);
|
||||
}
|
||||
|
||||
static int devm_rtc_device_match(struct device *dev, void *res, void *data)
|
||||
{
|
||||
struct rtc **r = res;
|
||||
|
||||
return *r == data;
|
||||
}
|
||||
|
||||
/**
|
||||
* devm_rtc_device_register - resource managed rtc_device_register()
|
||||
* @dev: the device to register
|
||||
* @name: the name of the device
|
||||
* @ops: the rtc operations structure
|
||||
* @owner: the module owner
|
||||
*
|
||||
* @return a struct rtc on success, or an ERR_PTR on error
|
||||
*
|
||||
* Managed rtc_device_register(). The rtc_device returned from this function
|
||||
* are automatically freed on driver detach. See rtc_device_register()
|
||||
* for more information.
|
||||
*/
|
||||
|
||||
struct rtc_device *devm_rtc_device_register(struct device *dev,
|
||||
const char *name,
|
||||
const struct rtc_class_ops *ops,
|
||||
struct module *owner)
|
||||
{
|
||||
struct rtc_device **ptr, *rtc;
|
||||
|
||||
ptr = devres_alloc(devm_rtc_device_release, sizeof(*ptr), GFP_KERNEL);
|
||||
if (!ptr)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
rtc = rtc_device_register(name, dev, ops, owner);
|
||||
if (!IS_ERR(rtc)) {
|
||||
*ptr = rtc;
|
||||
devres_add(dev, ptr);
|
||||
} else {
|
||||
devres_free(ptr);
|
||||
}
|
||||
|
||||
return rtc;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(devm_rtc_device_register);
|
||||
|
||||
/**
|
||||
* devm_rtc_device_unregister - resource managed devm_rtc_device_unregister()
|
||||
* @dev: the device to unregister
|
||||
* @rtc: the RTC class device to unregister
|
||||
*
|
||||
* Deallocated a rtc allocated with devm_rtc_device_register(). Normally this
|
||||
* function will not need to be called and the resource management code will
|
||||
* ensure that the resource is freed.
|
||||
*/
|
||||
void devm_rtc_device_unregister(struct device *dev, struct rtc_device *rtc)
|
||||
{
|
||||
int rc;
|
||||
|
||||
rc = devres_release(dev, devm_rtc_device_release,
|
||||
devm_rtc_device_match, rtc);
|
||||
WARN_ON(rc);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(devm_rtc_device_unregister);
|
||||
|
||||
static int __init rtc_init(void)
|
||||
{
|
||||
rtc_class = class_create(THIS_MODULE, "rtc");
|
||||
|
|
|
@ -234,7 +234,7 @@ static const struct rtc_class_ops pm80x_rtc_ops = {
|
|||
.alarm_irq_enable = pm80x_rtc_alarm_irq_enable,
|
||||
};
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
static int pm80x_rtc_suspend(struct device *dev)
|
||||
{
|
||||
return pm80x_dev_suspend(dev);
|
||||
|
@ -312,7 +312,7 @@ static int pm80x_rtc_probe(struct platform_device *pdev)
|
|||
}
|
||||
rtc_tm_to_time(&tm, &ticks);
|
||||
|
||||
info->rtc_dev = rtc_device_register("88pm80x-rtc", &pdev->dev,
|
||||
info->rtc_dev = devm_rtc_device_register(&pdev->dev, "88pm80x-rtc",
|
||||
&pm80x_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(info->rtc_dev)) {
|
||||
ret = PTR_ERR(info->rtc_dev);
|
||||
|
@ -346,7 +346,6 @@ static int pm80x_rtc_remove(struct platform_device *pdev)
|
|||
{
|
||||
struct pm80x_rtc_info *info = platform_get_drvdata(pdev);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
rtc_device_unregister(info->rtc_dev);
|
||||
pm80x_free_irq(info->chip, info->irq, info);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -318,14 +318,14 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
pdata = pdev->dev.platform_data;
|
||||
|
||||
info = kzalloc(sizeof(struct pm860x_rtc_info), GFP_KERNEL);
|
||||
info = devm_kzalloc(&pdev->dev, sizeof(struct pm860x_rtc_info),
|
||||
GFP_KERNEL);
|
||||
if (!info)
|
||||
return -ENOMEM;
|
||||
info->irq = platform_get_irq(pdev, 0);
|
||||
if (info->irq < 0) {
|
||||
dev_err(&pdev->dev, "No IRQ resource!\n");
|
||||
ret = -EINVAL;
|
||||
goto out;
|
||||
return info->irq;
|
||||
}
|
||||
|
||||
info->chip = chip;
|
||||
|
@ -333,12 +333,13 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
|
|||
info->dev = &pdev->dev;
|
||||
dev_set_drvdata(&pdev->dev, info);
|
||||
|
||||
ret = request_threaded_irq(info->irq, NULL, rtc_update_handler,
|
||||
IRQF_ONESHOT, "rtc", info);
|
||||
ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
|
||||
rtc_update_handler, IRQF_ONESHOT, "rtc",
|
||||
info);
|
||||
if (ret < 0) {
|
||||
dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
|
||||
info->irq, ret);
|
||||
goto out;
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* set addresses of 32-bit base value for RTC time */
|
||||
|
@ -350,7 +351,7 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
|
|||
ret = pm860x_rtc_read_time(&pdev->dev, &tm);
|
||||
if (ret < 0) {
|
||||
dev_err(&pdev->dev, "Failed to read initial time.\n");
|
||||
goto out_rtc;
|
||||
return ret;
|
||||
}
|
||||
if ((tm.tm_year < 70) || (tm.tm_year > 138)) {
|
||||
tm.tm_year = 70;
|
||||
|
@ -362,7 +363,7 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
|
|||
ret = pm860x_rtc_set_time(&pdev->dev, &tm);
|
||||
if (ret < 0) {
|
||||
dev_err(&pdev->dev, "Failed to set initial time.\n");
|
||||
goto out_rtc;
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
rtc_tm_to_time(&tm, &ticks);
|
||||
|
@ -373,12 +374,12 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
|
|||
}
|
||||
}
|
||||
|
||||
info->rtc_dev = rtc_device_register("88pm860x-rtc", &pdev->dev,
|
||||
info->rtc_dev = devm_rtc_device_register(&pdev->dev, "88pm860x-rtc",
|
||||
&pm860x_rtc_ops, THIS_MODULE);
|
||||
ret = PTR_ERR(info->rtc_dev);
|
||||
if (IS_ERR(info->rtc_dev)) {
|
||||
dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
|
||||
goto out_rtc;
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -405,11 +406,6 @@ static int pm860x_rtc_probe(struct platform_device *pdev)
|
|||
device_init_wakeup(&pdev->dev, 1);
|
||||
|
||||
return 0;
|
||||
out_rtc:
|
||||
free_irq(info->irq, info);
|
||||
out:
|
||||
kfree(info);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int pm860x_rtc_remove(struct platform_device *pdev)
|
||||
|
@ -423,9 +419,6 @@ static int pm860x_rtc_remove(struct platform_device *pdev)
|
|||
#endif /* VRTC_CALIBRATION */
|
||||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
rtc_device_unregister(info->rtc_dev);
|
||||
free_irq(info->irq, info);
|
||||
kfree(info);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -229,8 +229,8 @@ static int __init ab3100_rtc_probe(struct platform_device *pdev)
|
|||
/* Ignore any error on this write */
|
||||
}
|
||||
|
||||
rtc = rtc_device_register("ab3100-rtc", &pdev->dev, &ab3100_rtc_ops,
|
||||
THIS_MODULE);
|
||||
rtc = devm_rtc_device_register(&pdev->dev, "ab3100-rtc",
|
||||
&ab3100_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc)) {
|
||||
err = PTR_ERR(rtc);
|
||||
return err;
|
||||
|
@ -242,9 +242,6 @@ static int __init ab3100_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
static int __exit ab3100_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct rtc_device *rtc = platform_get_drvdata(pdev);
|
||||
|
||||
rtc_device_unregister(rtc);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
return 0;
|
||||
}
|
||||
|
@ -257,19 +254,7 @@ static struct platform_driver ab3100_rtc_driver = {
|
|||
.remove = __exit_p(ab3100_rtc_remove),
|
||||
};
|
||||
|
||||
static int __init ab3100_rtc_init(void)
|
||||
{
|
||||
return platform_driver_probe(&ab3100_rtc_driver,
|
||||
ab3100_rtc_probe);
|
||||
}
|
||||
|
||||
static void __exit ab3100_rtc_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&ab3100_rtc_driver);
|
||||
}
|
||||
|
||||
module_init(ab3100_rtc_init);
|
||||
module_exit(ab3100_rtc_exit);
|
||||
module_platform_driver_probe(ab3100_rtc_driver, ab3100_rtc_probe);
|
||||
|
||||
MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
|
||||
MODULE_DESCRIPTION("AB3100 RTC Driver");
|
||||
|
|
|
@ -422,20 +422,19 @@ static int ab8500_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
device_init_wakeup(&pdev->dev, true);
|
||||
|
||||
rtc = rtc_device_register("ab8500-rtc", &pdev->dev, &ab8500_rtc_ops,
|
||||
THIS_MODULE);
|
||||
rtc = devm_rtc_device_register(&pdev->dev, "ab8500-rtc",
|
||||
&ab8500_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc)) {
|
||||
dev_err(&pdev->dev, "Registration failed\n");
|
||||
err = PTR_ERR(rtc);
|
||||
return err;
|
||||
}
|
||||
|
||||
err = request_threaded_irq(irq, NULL, rtc_alarm_handler,
|
||||
IRQF_NO_SUSPEND | IRQF_ONESHOT, "ab8500-rtc", rtc);
|
||||
if (err < 0) {
|
||||
rtc_device_unregister(rtc);
|
||||
err = devm_request_threaded_irq(&pdev->dev, irq, NULL,
|
||||
rtc_alarm_handler, IRQF_NO_SUSPEND | IRQF_ONESHOT,
|
||||
"ab8500-rtc", rtc);
|
||||
if (err < 0)
|
||||
return err;
|
||||
}
|
||||
|
||||
platform_set_drvdata(pdev, rtc);
|
||||
|
||||
|
@ -450,13 +449,8 @@ static int ab8500_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
static int ab8500_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct rtc_device *rtc = platform_get_drvdata(pdev);
|
||||
int irq = platform_get_irq_byname(pdev, "ALARM");
|
||||
|
||||
ab8500_sysfs_rtc_unregister(&pdev->dev);
|
||||
|
||||
free_irq(irq, rtc);
|
||||
rtc_device_unregister(rtc);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -202,7 +202,8 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
|
|||
int irq;
|
||||
int ret;
|
||||
|
||||
rtc = kzalloc(sizeof(struct rtc_at32ap700x), GFP_KERNEL);
|
||||
rtc = devm_kzalloc(&pdev->dev, sizeof(struct rtc_at32ap700x),
|
||||
GFP_KERNEL);
|
||||
if (!rtc) {
|
||||
dev_dbg(&pdev->dev, "out of memory\n");
|
||||
return -ENOMEM;
|
||||
|
@ -223,7 +224,7 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
|
|||
}
|
||||
|
||||
rtc->irq = irq;
|
||||
rtc->regs = ioremap(regs->start, resource_size(regs));
|
||||
rtc->regs = devm_ioremap(&pdev->dev, regs->start, resource_size(regs));
|
||||
if (!rtc->regs) {
|
||||
ret = -ENOMEM;
|
||||
dev_dbg(&pdev->dev, "could not map I/O memory\n");
|
||||
|
@ -244,20 +245,21 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
|
|||
| RTC_BIT(CTRL_EN));
|
||||
}
|
||||
|
||||
ret = request_irq(irq, at32_rtc_interrupt, IRQF_SHARED, "rtc", rtc);
|
||||
ret = devm_request_irq(&pdev->dev, irq, at32_rtc_interrupt, IRQF_SHARED,
|
||||
"rtc", rtc);
|
||||
if (ret) {
|
||||
dev_dbg(&pdev->dev, "could not request irq %d\n", irq);
|
||||
goto out_iounmap;
|
||||
goto out;
|
||||
}
|
||||
|
||||
platform_set_drvdata(pdev, rtc);
|
||||
|
||||
rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
|
||||
rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&at32_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc->rtc)) {
|
||||
dev_dbg(&pdev->dev, "could not register rtc device\n");
|
||||
ret = PTR_ERR(rtc->rtc);
|
||||
goto out_free_irq;
|
||||
goto out;
|
||||
}
|
||||
|
||||
device_init_wakeup(&pdev->dev, 1);
|
||||
|
@ -267,26 +269,15 @@ static int __init at32_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
return 0;
|
||||
|
||||
out_free_irq:
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
free_irq(irq, rtc);
|
||||
out_iounmap:
|
||||
iounmap(rtc->regs);
|
||||
out:
|
||||
kfree(rtc);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int __exit at32_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct rtc_at32ap700x *rtc = platform_get_drvdata(pdev);
|
||||
|
||||
device_init_wakeup(&pdev->dev, 0);
|
||||
|
||||
free_irq(rtc->irq, rtc);
|
||||
iounmap(rtc->regs);
|
||||
rtc_device_unregister(rtc->rtc);
|
||||
kfree(rtc);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
|
@ -302,17 +293,7 @@ static struct platform_driver at32_rtc_driver = {
|
|||
},
|
||||
};
|
||||
|
||||
static int __init at32_rtc_init(void)
|
||||
{
|
||||
return platform_driver_probe(&at32_rtc_driver, at32_rtc_probe);
|
||||
}
|
||||
module_init(at32_rtc_init);
|
||||
|
||||
static void __exit at32_rtc_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&at32_rtc_driver);
|
||||
}
|
||||
module_exit(at32_rtc_exit);
|
||||
module_platform_driver_probe(at32_rtc_driver, at32_rtc_probe);
|
||||
|
||||
MODULE_AUTHOR("Hans-Christian Egtvedt <hcegtvedt@atmel.com>");
|
||||
MODULE_DESCRIPTION("Real time clock for AVR32 AT32AP700x");
|
||||
|
|
|
@ -28,6 +28,8 @@
|
|||
#include <linux/ioctl.h>
|
||||
#include <linux/completion.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_device.h>
|
||||
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
|
@ -297,7 +299,7 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
|
|||
"at91_rtc", pdev);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "IRQ %d already in use.\n", irq);
|
||||
return ret;
|
||||
goto err_unmap;
|
||||
}
|
||||
|
||||
/* cpu init code should really have flagged this device as
|
||||
|
@ -309,13 +311,20 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
|
|||
rtc = rtc_device_register(pdev->name, &pdev->dev,
|
||||
&at91_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc)) {
|
||||
free_irq(irq, pdev);
|
||||
return PTR_ERR(rtc);
|
||||
ret = PTR_ERR(rtc);
|
||||
goto err_free_irq;
|
||||
}
|
||||
platform_set_drvdata(pdev, rtc);
|
||||
|
||||
dev_info(&pdev->dev, "AT91 Real Time Clock driver.\n");
|
||||
return 0;
|
||||
|
||||
err_free_irq:
|
||||
free_irq(irq, pdev);
|
||||
err_unmap:
|
||||
iounmap(at91_rtc_regs);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -332,12 +341,13 @@ static int __exit at91_rtc_remove(struct platform_device *pdev)
|
|||
free_irq(irq, pdev);
|
||||
|
||||
rtc_device_unregister(rtc);
|
||||
iounmap(at91_rtc_regs);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
|
||||
/* AT91RM9200 RTC Power management control */
|
||||
|
||||
|
@ -369,39 +379,27 @@ static int at91_rtc_resume(struct device *dev)
|
|||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct dev_pm_ops at91_rtc_pm = {
|
||||
.suspend = at91_rtc_suspend,
|
||||
.resume = at91_rtc_resume,
|
||||
};
|
||||
|
||||
#define at91_rtc_pm_ptr &at91_rtc_pm
|
||||
|
||||
#else
|
||||
#define at91_rtc_pm_ptr NULL
|
||||
#endif
|
||||
|
||||
static SIMPLE_DEV_PM_OPS(at91_rtc_pm_ops, at91_rtc_suspend, at91_rtc_resume);
|
||||
|
||||
static const struct of_device_id at91_rtc_dt_ids[] = {
|
||||
{ .compatible = "atmel,at91rm9200-rtc" },
|
||||
{ /* sentinel */ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(of, at91_rtc_dt_ids);
|
||||
|
||||
static struct platform_driver at91_rtc_driver = {
|
||||
.remove = __exit_p(at91_rtc_remove),
|
||||
.driver = {
|
||||
.name = "at91_rtc",
|
||||
.owner = THIS_MODULE,
|
||||
.pm = at91_rtc_pm_ptr,
|
||||
.pm = &at91_rtc_pm_ops,
|
||||
.of_match_table = of_match_ptr(at91_rtc_dt_ids),
|
||||
},
|
||||
};
|
||||
|
||||
static int __init at91_rtc_init(void)
|
||||
{
|
||||
return platform_driver_probe(&at91_rtc_driver, at91_rtc_probe);
|
||||
}
|
||||
|
||||
static void __exit at91_rtc_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&at91_rtc_driver);
|
||||
}
|
||||
|
||||
module_init(at91_rtc_init);
|
||||
module_exit(at91_rtc_exit);
|
||||
module_platform_driver_probe(at91_rtc_driver, at91_rtc_probe);
|
||||
|
||||
MODULE_AUTHOR("Rick Bronson");
|
||||
MODULE_DESCRIPTION("RTC driver for Atmel AT91RM9200");
|
||||
|
|
|
@ -20,6 +20,7 @@
|
|||
#include <linux/ioctl.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/platform_data/atmel.h>
|
||||
#include <linux/io.h>
|
||||
|
||||
#include <mach/at91_rtt.h>
|
||||
#include <mach/cpu.h>
|
||||
|
@ -309,7 +310,7 @@ static int at91_rtc_probe(struct platform_device *pdev)
|
|||
return irq;
|
||||
}
|
||||
|
||||
rtc = kzalloc(sizeof *rtc, GFP_KERNEL);
|
||||
rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
|
||||
if (!rtc)
|
||||
return -ENOMEM;
|
||||
|
||||
|
@ -320,18 +321,19 @@ static int at91_rtc_probe(struct platform_device *pdev)
|
|||
device_init_wakeup(&pdev->dev, 1);
|
||||
|
||||
platform_set_drvdata(pdev, rtc);
|
||||
rtc->rtt = ioremap(r->start, resource_size(r));
|
||||
rtc->rtt = devm_ioremap(&pdev->dev, r->start, resource_size(r));
|
||||
if (!rtc->rtt) {
|
||||
dev_err(&pdev->dev, "failed to map registers, aborting.\n");
|
||||
ret = -ENOMEM;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
rtc->gpbr = ioremap(r_gpbr->start, resource_size(r_gpbr));
|
||||
rtc->gpbr = devm_ioremap(&pdev->dev, r_gpbr->start,
|
||||
resource_size(r_gpbr));
|
||||
if (!rtc->gpbr) {
|
||||
dev_err(&pdev->dev, "failed to map gpbr registers, aborting.\n");
|
||||
ret = -ENOMEM;
|
||||
goto fail_gpbr;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
mr = rtt_readl(rtc, MR);
|
||||
|
@ -346,20 +348,19 @@ static int at91_rtc_probe(struct platform_device *pdev)
|
|||
mr &= ~(AT91_RTT_ALMIEN | AT91_RTT_RTTINCIEN);
|
||||
rtt_writel(rtc, MR, mr);
|
||||
|
||||
rtc->rtcdev = rtc_device_register(pdev->name, &pdev->dev,
|
||||
&at91_rtc_ops, THIS_MODULE);
|
||||
rtc->rtcdev = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&at91_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc->rtcdev)) {
|
||||
ret = PTR_ERR(rtc->rtcdev);
|
||||
goto fail_register;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
/* register irq handler after we know what name we'll use */
|
||||
ret = request_irq(rtc->irq, at91_rtc_interrupt, IRQF_SHARED,
|
||||
dev_name(&rtc->rtcdev->dev), rtc);
|
||||
ret = devm_request_irq(&pdev->dev, rtc->irq, at91_rtc_interrupt,
|
||||
IRQF_SHARED, dev_name(&rtc->rtcdev->dev), rtc);
|
||||
if (ret) {
|
||||
dev_dbg(&pdev->dev, "can't share IRQ %d?\n", rtc->irq);
|
||||
rtc_device_unregister(rtc->rtcdev);
|
||||
goto fail_register;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
/* NOTE: sam9260 rev A silicon has a ROM bug which resets the
|
||||
|
@ -374,13 +375,8 @@ static int at91_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
return 0;
|
||||
|
||||
fail_register:
|
||||
iounmap(rtc->gpbr);
|
||||
fail_gpbr:
|
||||
iounmap(rtc->rtt);
|
||||
fail:
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
kfree(rtc);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -394,14 +390,8 @@ static int at91_rtc_remove(struct platform_device *pdev)
|
|||
|
||||
/* disable all interrupts */
|
||||
rtt_writel(rtc, MR, mr & ~(AT91_RTT_ALMIEN | AT91_RTT_RTTINCIEN));
|
||||
free_irq(rtc->irq, rtc);
|
||||
|
||||
rtc_device_unregister(rtc->rtcdev);
|
||||
|
||||
iounmap(rtc->gpbr);
|
||||
iounmap(rtc->rtt);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
kfree(rtc);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -414,14 +404,13 @@ static void at91_rtc_shutdown(struct platform_device *pdev)
|
|||
rtt_writel(rtc, MR, mr & ~rtc->imr);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
|
||||
/* AT91SAM9 RTC Power management control */
|
||||
|
||||
static int at91_rtc_suspend(struct platform_device *pdev,
|
||||
pm_message_t state)
|
||||
static int at91_rtc_suspend(struct device *dev)
|
||||
{
|
||||
struct sam9_rtc *rtc = platform_get_drvdata(pdev);
|
||||
struct sam9_rtc *rtc = dev_get_drvdata(dev);
|
||||
u32 mr = rtt_readl(rtc, MR);
|
||||
|
||||
/*
|
||||
|
@ -430,7 +419,7 @@ static int at91_rtc_suspend(struct platform_device *pdev,
|
|||
*/
|
||||
rtc->imr = mr & (AT91_RTT_ALMIEN | AT91_RTT_RTTINCIEN);
|
||||
if (rtc->imr) {
|
||||
if (device_may_wakeup(&pdev->dev) && (mr & AT91_RTT_ALMIEN)) {
|
||||
if (device_may_wakeup(dev) && (mr & AT91_RTT_ALMIEN)) {
|
||||
enable_irq_wake(rtc->irq);
|
||||
/* don't let RTTINC cause wakeups */
|
||||
if (mr & AT91_RTT_RTTINCIEN)
|
||||
|
@ -442,13 +431,13 @@ static int at91_rtc_suspend(struct platform_device *pdev,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int at91_rtc_resume(struct platform_device *pdev)
|
||||
static int at91_rtc_resume(struct device *dev)
|
||||
{
|
||||
struct sam9_rtc *rtc = platform_get_drvdata(pdev);
|
||||
struct sam9_rtc *rtc = dev_get_drvdata(dev);
|
||||
u32 mr;
|
||||
|
||||
if (rtc->imr) {
|
||||
if (device_may_wakeup(&pdev->dev))
|
||||
if (device_may_wakeup(dev))
|
||||
disable_irq_wake(rtc->irq);
|
||||
mr = rtt_readl(rtc, MR);
|
||||
rtt_writel(rtc, MR, mr | rtc->imr);
|
||||
|
@ -456,20 +445,18 @@ static int at91_rtc_resume(struct platform_device *pdev)
|
|||
|
||||
return 0;
|
||||
}
|
||||
#else
|
||||
#define at91_rtc_suspend NULL
|
||||
#define at91_rtc_resume NULL
|
||||
#endif
|
||||
|
||||
static SIMPLE_DEV_PM_OPS(at91_rtc_pm_ops, at91_rtc_suspend, at91_rtc_resume);
|
||||
|
||||
static struct platform_driver at91_rtc_driver = {
|
||||
.probe = at91_rtc_probe,
|
||||
.remove = at91_rtc_remove,
|
||||
.shutdown = at91_rtc_shutdown,
|
||||
.suspend = at91_rtc_suspend,
|
||||
.resume = at91_rtc_resume,
|
||||
.driver = {
|
||||
.name = "rtc-at91sam9",
|
||||
.owner = THIS_MODULE,
|
||||
.pm = &at91_rtc_pm_ops,
|
||||
},
|
||||
};
|
||||
|
||||
|
|
|
@ -101,7 +101,7 @@ static int au1xtoy_rtc_probe(struct platform_device *pdev)
|
|||
while (au_readl(SYS_COUNTER_CNTRL) & SYS_CNTRL_C0S)
|
||||
msleep(1);
|
||||
|
||||
rtcdev = rtc_device_register("rtc-au1xxx", &pdev->dev,
|
||||
rtcdev = devm_rtc_device_register(&pdev->dev, "rtc-au1xxx",
|
||||
&au1xtoy_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtcdev)) {
|
||||
ret = PTR_ERR(rtcdev);
|
||||
|
@ -118,9 +118,6 @@ out_err:
|
|||
|
||||
static int au1xtoy_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct rtc_device *rtcdev = platform_get_drvdata(pdev);
|
||||
|
||||
rtc_device_unregister(rtcdev);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
|
@ -134,18 +131,7 @@ static struct platform_driver au1xrtc_driver = {
|
|||
.remove = au1xtoy_rtc_remove,
|
||||
};
|
||||
|
||||
static int __init au1xtoy_rtc_init(void)
|
||||
{
|
||||
return platform_driver_probe(&au1xrtc_driver, au1xtoy_rtc_probe);
|
||||
}
|
||||
|
||||
static void __exit au1xtoy_rtc_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&au1xrtc_driver);
|
||||
}
|
||||
|
||||
module_init(au1xtoy_rtc_init);
|
||||
module_exit(au1xtoy_rtc_exit);
|
||||
module_platform_driver_probe(au1xrtc_driver, au1xtoy_rtc_probe);
|
||||
|
||||
MODULE_DESCRIPTION("Au1xxx TOY-counter-based RTC driver");
|
||||
MODULE_AUTHOR("Manuel Lauss <manuel.lauss@gmail.com>");
|
||||
|
|
|
@ -352,14 +352,14 @@ static int bfin_rtc_probe(struct platform_device *pdev)
|
|||
dev_dbg_stamp(dev);
|
||||
|
||||
/* Allocate memory for our RTC struct */
|
||||
rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
|
||||
rtc = devm_kzalloc(dev, sizeof(*rtc), GFP_KERNEL);
|
||||
if (unlikely(!rtc))
|
||||
return -ENOMEM;
|
||||
platform_set_drvdata(pdev, rtc);
|
||||
device_init_wakeup(dev, 1);
|
||||
|
||||
/* Register our RTC with the RTC framework */
|
||||
rtc->rtc_dev = rtc_device_register(pdev->name, dev, &bfin_rtc_ops,
|
||||
rtc->rtc_dev = devm_rtc_device_register(dev, pdev->name, &bfin_rtc_ops,
|
||||
THIS_MODULE);
|
||||
if (unlikely(IS_ERR(rtc->rtc_dev))) {
|
||||
ret = PTR_ERR(rtc->rtc_dev);
|
||||
|
@ -367,9 +367,10 @@ static int bfin_rtc_probe(struct platform_device *pdev)
|
|||
}
|
||||
|
||||
/* Grab the IRQ and init the hardware */
|
||||
ret = request_irq(IRQ_RTC, bfin_rtc_interrupt, 0, pdev->name, dev);
|
||||
ret = devm_request_irq(dev, IRQ_RTC, bfin_rtc_interrupt, 0,
|
||||
pdev->name, dev);
|
||||
if (unlikely(ret))
|
||||
goto err_reg;
|
||||
goto err;
|
||||
/* sometimes the bootloader touched things, but the write complete was not
|
||||
* enabled, so let's just do a quick timeout here since the IRQ will not fire ...
|
||||
*/
|
||||
|
@ -381,32 +382,23 @@ static int bfin_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
return 0;
|
||||
|
||||
err_reg:
|
||||
rtc_device_unregister(rtc->rtc_dev);
|
||||
err:
|
||||
kfree(rtc);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int bfin_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct bfin_rtc *rtc = platform_get_drvdata(pdev);
|
||||
struct device *dev = &pdev->dev;
|
||||
|
||||
bfin_rtc_reset(dev, 0);
|
||||
free_irq(IRQ_RTC, dev);
|
||||
rtc_device_unregister(rtc->rtc_dev);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
kfree(rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
static int bfin_rtc_suspend(struct platform_device *pdev, pm_message_t state)
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
static int bfin_rtc_suspend(struct device *dev)
|
||||
{
|
||||
struct device *dev = &pdev->dev;
|
||||
|
||||
dev_dbg_stamp(dev);
|
||||
|
||||
if (device_may_wakeup(dev)) {
|
||||
|
@ -418,10 +410,8 @@ static int bfin_rtc_suspend(struct platform_device *pdev, pm_message_t state)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int bfin_rtc_resume(struct platform_device *pdev)
|
||||
static int bfin_rtc_resume(struct device *dev)
|
||||
{
|
||||
struct device *dev = &pdev->dev;
|
||||
|
||||
dev_dbg_stamp(dev);
|
||||
|
||||
if (device_may_wakeup(dev))
|
||||
|
@ -440,20 +430,18 @@ static int bfin_rtc_resume(struct platform_device *pdev)
|
|||
|
||||
return 0;
|
||||
}
|
||||
#else
|
||||
# define bfin_rtc_suspend NULL
|
||||
# define bfin_rtc_resume NULL
|
||||
#endif
|
||||
|
||||
static SIMPLE_DEV_PM_OPS(bfin_rtc_pm_ops, bfin_rtc_suspend, bfin_rtc_resume);
|
||||
|
||||
static struct platform_driver bfin_rtc_driver = {
|
||||
.driver = {
|
||||
.name = "rtc-bfin",
|
||||
.owner = THIS_MODULE,
|
||||
.pm = &bfin_rtc_pm_ops,
|
||||
},
|
||||
.probe = bfin_rtc_probe,
|
||||
.remove = bfin_rtc_remove,
|
||||
.suspend = bfin_rtc_suspend,
|
||||
.resume = bfin_rtc_resume,
|
||||
};
|
||||
|
||||
module_platform_driver(bfin_rtc_driver);
|
||||
|
|
|
@ -153,7 +153,7 @@ static int bq32k_probe(struct i2c_client *client,
|
|||
if (error)
|
||||
return error;
|
||||
|
||||
rtc = rtc_device_register(bq32k_driver.driver.name, &client->dev,
|
||||
rtc = devm_rtc_device_register(&client->dev, bq32k_driver.driver.name,
|
||||
&bq32k_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
|
@ -165,9 +165,6 @@ static int bq32k_probe(struct i2c_client *client,
|
|||
|
||||
static int bq32k_remove(struct i2c_client *client)
|
||||
{
|
||||
struct rtc_device *rtc = i2c_get_clientdata(client);
|
||||
|
||||
rtc_device_unregister(rtc);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -142,7 +142,7 @@ static const struct rtc_class_ops bq4802_ops = {
|
|||
|
||||
static int bq4802_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct bq4802 *p = kzalloc(sizeof(*p), GFP_KERNEL);
|
||||
struct bq4802 *p = devm_kzalloc(&pdev->dev, sizeof(*p), GFP_KERNEL);
|
||||
int err = -ENOMEM;
|
||||
|
||||
if (!p)
|
||||
|
@ -155,54 +155,41 @@ static int bq4802_probe(struct platform_device *pdev)
|
|||
p->r = platform_get_resource(pdev, IORESOURCE_IO, 0);
|
||||
err = -EINVAL;
|
||||
if (!p->r)
|
||||
goto out_free;
|
||||
goto out;
|
||||
}
|
||||
if (p->r->flags & IORESOURCE_IO) {
|
||||
p->ioport = p->r->start;
|
||||
p->read = bq4802_read_io;
|
||||
p->write = bq4802_write_io;
|
||||
} else if (p->r->flags & IORESOURCE_MEM) {
|
||||
p->regs = ioremap(p->r->start, resource_size(p->r));
|
||||
p->regs = devm_ioremap(&pdev->dev, p->r->start,
|
||||
resource_size(p->r));
|
||||
p->read = bq4802_read_mem;
|
||||
p->write = bq4802_write_mem;
|
||||
} else {
|
||||
err = -EINVAL;
|
||||
goto out_free;
|
||||
goto out;
|
||||
}
|
||||
|
||||
platform_set_drvdata(pdev, p);
|
||||
|
||||
p->rtc = rtc_device_register("bq4802", &pdev->dev,
|
||||
&bq4802_ops, THIS_MODULE);
|
||||
p->rtc = devm_rtc_device_register(&pdev->dev, "bq4802",
|
||||
&bq4802_ops, THIS_MODULE);
|
||||
if (IS_ERR(p->rtc)) {
|
||||
err = PTR_ERR(p->rtc);
|
||||
goto out_iounmap;
|
||||
goto out;
|
||||
}
|
||||
|
||||
err = 0;
|
||||
out:
|
||||
return err;
|
||||
|
||||
out_iounmap:
|
||||
if (p->r->flags & IORESOURCE_MEM)
|
||||
iounmap(p->regs);
|
||||
out_free:
|
||||
kfree(p);
|
||||
goto out;
|
||||
}
|
||||
|
||||
static int bq4802_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct bq4802 *p = platform_get_drvdata(pdev);
|
||||
|
||||
rtc_device_unregister(p->rtc);
|
||||
if (p->r->flags & IORESOURCE_MEM)
|
||||
iounmap(p->regs);
|
||||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
kfree(p);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -804,9 +804,8 @@ static int cmos_suspend(struct device *dev)
|
|||
mask = RTC_IRQMASK;
|
||||
tmp &= ~mask;
|
||||
CMOS_WRITE(tmp, RTC_CONTROL);
|
||||
hpet_mask_rtc_irq_bit(mask);
|
||||
|
||||
/* shut down hpet emulation - we don't need it for alarm */
|
||||
hpet_mask_rtc_irq_bit(RTC_PIE|RTC_AIE|RTC_UIE);
|
||||
cmos_checkintr(cmos, tmp);
|
||||
}
|
||||
spin_unlock_irq(&rtc_lock);
|
||||
|
@ -870,6 +869,7 @@ static int cmos_resume(struct device *dev)
|
|||
rtc_update_irq(cmos->rtc, 1, mask);
|
||||
tmp &= ~RTC_AIE;
|
||||
hpet_mask_rtc_irq_bit(RTC_AIE);
|
||||
hpet_rtc_timer_init();
|
||||
} while (mask & RTC_AIE);
|
||||
spin_unlock_irq(&rtc_lock);
|
||||
}
|
||||
|
|
|
@ -47,7 +47,7 @@ struct coh901331_port {
|
|||
u32 physize;
|
||||
void __iomem *virtbase;
|
||||
int irq;
|
||||
#ifdef CONFIG_PM
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
u32 irqmaskstore;
|
||||
#endif
|
||||
};
|
||||
|
@ -155,7 +155,6 @@ static int __exit coh901331_remove(struct platform_device *pdev)
|
|||
struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
|
||||
|
||||
if (rtap) {
|
||||
rtc_device_unregister(rtap->rtc);
|
||||
clk_unprepare(rtap->clk);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
}
|
||||
|
@ -211,8 +210,8 @@ static int __init coh901331_probe(struct platform_device *pdev)
|
|||
clk_disable(rtap->clk);
|
||||
|
||||
platform_set_drvdata(pdev, rtap);
|
||||
rtap->rtc = rtc_device_register("coh901331", &pdev->dev, &coh901331_ops,
|
||||
THIS_MODULE);
|
||||
rtap->rtc = devm_rtc_device_register(&pdev->dev, "coh901331",
|
||||
&coh901331_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtap->rtc)) {
|
||||
ret = PTR_ERR(rtap->rtc);
|
||||
goto out_no_rtc;
|
||||
|
@ -226,17 +225,17 @@ static int __init coh901331_probe(struct platform_device *pdev)
|
|||
return ret;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
static int coh901331_suspend(struct platform_device *pdev, pm_message_t state)
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
static int coh901331_suspend(struct device *dev)
|
||||
{
|
||||
struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
|
||||
struct coh901331_port *rtap = dev_get_drvdata(dev);
|
||||
|
||||
/*
|
||||
* If this RTC alarm will be used for waking the system up,
|
||||
* don't disable it of course. Else we just disable the alarm
|
||||
* and await suspension.
|
||||
*/
|
||||
if (device_may_wakeup(&pdev->dev)) {
|
||||
if (device_may_wakeup(dev)) {
|
||||
enable_irq_wake(rtap->irq);
|
||||
} else {
|
||||
clk_enable(rtap->clk);
|
||||
|
@ -248,12 +247,12 @@ static int coh901331_suspend(struct platform_device *pdev, pm_message_t state)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int coh901331_resume(struct platform_device *pdev)
|
||||
static int coh901331_resume(struct device *dev)
|
||||
{
|
||||
struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
|
||||
struct coh901331_port *rtap = dev_get_drvdata(dev);
|
||||
|
||||
clk_prepare(rtap->clk);
|
||||
if (device_may_wakeup(&pdev->dev)) {
|
||||
if (device_may_wakeup(dev)) {
|
||||
disable_irq_wake(rtap->irq);
|
||||
} else {
|
||||
clk_enable(rtap->clk);
|
||||
|
@ -262,11 +261,10 @@ static int coh901331_resume(struct platform_device *pdev)
|
|||
}
|
||||
return 0;
|
||||
}
|
||||
#else
|
||||
#define coh901331_suspend NULL
|
||||
#define coh901331_resume NULL
|
||||
#endif
|
||||
|
||||
static SIMPLE_DEV_PM_OPS(coh901331_pm_ops, coh901331_suspend, coh901331_resume);
|
||||
|
||||
static void coh901331_shutdown(struct platform_device *pdev)
|
||||
{
|
||||
struct coh901331_port *rtap = dev_get_drvdata(&pdev->dev);
|
||||
|
@ -280,25 +278,13 @@ static struct platform_driver coh901331_driver = {
|
|||
.driver = {
|
||||
.name = "rtc-coh901331",
|
||||
.owner = THIS_MODULE,
|
||||
.pm = &coh901331_pm_ops,
|
||||
},
|
||||
.remove = __exit_p(coh901331_remove),
|
||||
.suspend = coh901331_suspend,
|
||||
.resume = coh901331_resume,
|
||||
.shutdown = coh901331_shutdown,
|
||||
};
|
||||
|
||||
static int __init coh901331_init(void)
|
||||
{
|
||||
return platform_driver_probe(&coh901331_driver, coh901331_probe);
|
||||
}
|
||||
|
||||
static void __exit coh901331_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&coh901331_driver);
|
||||
}
|
||||
|
||||
module_init(coh901331_init);
|
||||
module_exit(coh901331_exit);
|
||||
module_platform_driver_probe(coh901331_driver, coh901331_probe);
|
||||
|
||||
MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
|
||||
MODULE_DESCRIPTION("ST-Ericsson AB COH 901 331 RTC Driver");
|
||||
|
|
|
@ -247,7 +247,7 @@ static int da9052_rtc_probe(struct platform_device *pdev)
|
|||
return ret;
|
||||
}
|
||||
|
||||
rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
|
||||
rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&da9052_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc->rtc))
|
||||
return PTR_ERR(rtc->rtc);
|
||||
|
@ -257,9 +257,6 @@ static int da9052_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
static int da9052_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct da9052_rtc *rtc = pdev->dev.platform_data;
|
||||
|
||||
rtc_device_unregister(rtc->rtc);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -294,7 +294,7 @@ static int da9055_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
device_init_wakeup(&pdev->dev, 1);
|
||||
|
||||
rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
|
||||
rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&da9055_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc->rtc)) {
|
||||
ret = PTR_ERR(rtc->rtc);
|
||||
|
@ -317,9 +317,6 @@ err_rtc:
|
|||
|
||||
static int da9055_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct da9055_rtc *rtc = pdev->dev.platform_data;
|
||||
|
||||
rtc_device_unregister(rtc->rtc);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -523,7 +523,7 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
platform_set_drvdata(pdev, davinci_rtc);
|
||||
|
||||
davinci_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
|
||||
davinci_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&davinci_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(davinci_rtc->rtc)) {
|
||||
ret = PTR_ERR(davinci_rtc->rtc);
|
||||
|
@ -543,7 +543,7 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
|
|||
0, "davinci_rtc", davinci_rtc);
|
||||
if (ret < 0) {
|
||||
dev_err(dev, "unable to register davinci RTC interrupt\n");
|
||||
goto fail2;
|
||||
goto fail1;
|
||||
}
|
||||
|
||||
/* Enable interrupts */
|
||||
|
@ -557,14 +557,12 @@ static int __init davinci_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
return 0;
|
||||
|
||||
fail2:
|
||||
rtc_device_unregister(davinci_rtc->rtc);
|
||||
fail1:
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int davinci_rtc_remove(struct platform_device *pdev)
|
||||
static int __exit davinci_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct davinci_rtc *davinci_rtc = platform_get_drvdata(pdev);
|
||||
|
||||
|
@ -572,8 +570,6 @@ static int davinci_rtc_remove(struct platform_device *pdev)
|
|||
|
||||
rtcif_write(davinci_rtc, 0, PRTCIF_INTEN);
|
||||
|
||||
rtc_device_unregister(davinci_rtc->rtc);
|
||||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
|
@ -581,24 +577,14 @@ static int davinci_rtc_remove(struct platform_device *pdev)
|
|||
|
||||
static struct platform_driver davinci_rtc_driver = {
|
||||
.probe = davinci_rtc_probe,
|
||||
.remove = davinci_rtc_remove,
|
||||
.remove = __exit_p(davinci_rtc_remove),
|
||||
.driver = {
|
||||
.name = "rtc_davinci",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init rtc_init(void)
|
||||
{
|
||||
return platform_driver_probe(&davinci_rtc_driver, davinci_rtc_probe);
|
||||
}
|
||||
module_init(rtc_init);
|
||||
|
||||
static void __exit rtc_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&davinci_rtc_driver);
|
||||
}
|
||||
module_exit(rtc_exit);
|
||||
module_platform_driver_probe(davinci_rtc_driver, davinci_rtc_probe);
|
||||
|
||||
MODULE_AUTHOR("Miguel Aguilar <miguel.aguilar@ridgerun.com>");
|
||||
MODULE_DESCRIPTION("Texas Instruments DaVinci PRTC Driver");
|
||||
|
|
|
@ -127,8 +127,8 @@ static int dm355evm_rtc_probe(struct platform_device *pdev)
|
|||
{
|
||||
struct rtc_device *rtc;
|
||||
|
||||
rtc = rtc_device_register(pdev->name,
|
||||
&pdev->dev, &dm355evm_rtc_ops, THIS_MODULE);
|
||||
rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&dm355evm_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc)) {
|
||||
dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
|
||||
PTR_ERR(rtc));
|
||||
|
@ -141,9 +141,6 @@ static int dm355evm_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
static int dm355evm_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct rtc_device *rtc = platform_get_drvdata(pdev);
|
||||
|
||||
rtc_device_unregister(rtc);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -30,8 +30,6 @@ struct ds1216_regs {
|
|||
struct ds1216_priv {
|
||||
struct rtc_device *rtc;
|
||||
void __iomem *ioaddr;
|
||||
size_t size;
|
||||
unsigned long baseaddr;
|
||||
};
|
||||
|
||||
static const u8 magic[] = {
|
||||
|
@ -144,57 +142,33 @@ static int __init ds1216_rtc_probe(struct platform_device *pdev)
|
|||
{
|
||||
struct resource *res;
|
||||
struct ds1216_priv *priv;
|
||||
int ret = 0;
|
||||
u8 dummy[8];
|
||||
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
if (!res)
|
||||
return -ENODEV;
|
||||
priv = kzalloc(sizeof *priv, GFP_KERNEL);
|
||||
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
|
||||
if (!priv)
|
||||
return -ENOMEM;
|
||||
|
||||
platform_set_drvdata(pdev, priv);
|
||||
|
||||
priv->size = resource_size(res);
|
||||
if (!request_mem_region(res->start, priv->size, pdev->name)) {
|
||||
ret = -EBUSY;
|
||||
goto out;
|
||||
}
|
||||
priv->baseaddr = res->start;
|
||||
priv->ioaddr = ioremap(priv->baseaddr, priv->size);
|
||||
if (!priv->ioaddr) {
|
||||
ret = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
priv->rtc = rtc_device_register("ds1216", &pdev->dev,
|
||||
&ds1216_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(priv->rtc)) {
|
||||
ret = PTR_ERR(priv->rtc);
|
||||
goto out;
|
||||
}
|
||||
priv->ioaddr = devm_ioremap_resource(&pdev->dev, res);
|
||||
if (IS_ERR(priv->ioaddr))
|
||||
return PTR_ERR(priv->ioaddr);
|
||||
|
||||
priv->rtc = devm_rtc_device_register(&pdev->dev, "ds1216",
|
||||
&ds1216_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(priv->rtc))
|
||||
return PTR_ERR(priv->rtc);
|
||||
|
||||
/* dummy read to get clock into a known state */
|
||||
ds1216_read(priv->ioaddr, dummy);
|
||||
return 0;
|
||||
|
||||
out:
|
||||
if (priv->ioaddr)
|
||||
iounmap(priv->ioaddr);
|
||||
if (priv->baseaddr)
|
||||
release_mem_region(priv->baseaddr, priv->size);
|
||||
kfree(priv);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int __exit ds1216_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct ds1216_priv *priv = platform_get_drvdata(pdev);
|
||||
|
||||
rtc_device_unregister(priv->rtc);
|
||||
iounmap(priv->ioaddr);
|
||||
release_mem_region(priv->baseaddr, priv->size);
|
||||
kfree(priv);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -25,8 +25,6 @@
|
|||
struct ds1286_priv {
|
||||
struct rtc_device *rtc;
|
||||
u32 __iomem *rtcregs;
|
||||
size_t size;
|
||||
unsigned long baseaddr;
|
||||
spinlock_t lock;
|
||||
};
|
||||
|
||||
|
@ -270,7 +268,6 @@ static int ds1286_set_time(struct device *dev, struct rtc_time *tm)
|
|||
static int ds1286_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
|
||||
{
|
||||
struct ds1286_priv *priv = dev_get_drvdata(dev);
|
||||
unsigned char cmd;
|
||||
unsigned long flags;
|
||||
|
||||
/*
|
||||
|
@ -281,7 +278,7 @@ static int ds1286_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
|
|||
alm->time.tm_min = ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x7f;
|
||||
alm->time.tm_hour = ds1286_rtc_read(priv, RTC_HOURS_ALARM) & 0x1f;
|
||||
alm->time.tm_wday = ds1286_rtc_read(priv, RTC_DAY_ALARM) & 0x07;
|
||||
cmd = ds1286_rtc_read(priv, RTC_CMD);
|
||||
ds1286_rtc_read(priv, RTC_CMD);
|
||||
spin_unlock_irqrestore(&priv->lock, flags);
|
||||
|
||||
alm->time.tm_min = bcd2bin(alm->time.tm_min);
|
||||
|
@ -334,56 +331,30 @@ static int ds1286_probe(struct platform_device *pdev)
|
|||
struct rtc_device *rtc;
|
||||
struct resource *res;
|
||||
struct ds1286_priv *priv;
|
||||
int ret = 0;
|
||||
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
if (!res)
|
||||
return -ENODEV;
|
||||
priv = kzalloc(sizeof(struct ds1286_priv), GFP_KERNEL);
|
||||
priv = devm_kzalloc(&pdev->dev, sizeof(struct ds1286_priv), GFP_KERNEL);
|
||||
if (!priv)
|
||||
return -ENOMEM;
|
||||
|
||||
priv->size = resource_size(res);
|
||||
if (!request_mem_region(res->start, priv->size, pdev->name)) {
|
||||
ret = -EBUSY;
|
||||
goto out;
|
||||
}
|
||||
priv->baseaddr = res->start;
|
||||
priv->rtcregs = ioremap(priv->baseaddr, priv->size);
|
||||
if (!priv->rtcregs) {
|
||||
ret = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
priv->rtcregs = devm_ioremap_resource(&pdev->dev, res);
|
||||
if (IS_ERR(priv->rtcregs))
|
||||
return PTR_ERR(priv->rtcregs);
|
||||
|
||||
spin_lock_init(&priv->lock);
|
||||
platform_set_drvdata(pdev, priv);
|
||||
rtc = rtc_device_register("ds1286", &pdev->dev,
|
||||
&ds1286_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc)) {
|
||||
ret = PTR_ERR(rtc);
|
||||
goto out;
|
||||
}
|
||||
rtc = devm_rtc_device_register(&pdev->dev, "ds1286", &ds1286_ops,
|
||||
THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
priv->rtc = rtc;
|
||||
return 0;
|
||||
|
||||
out:
|
||||
if (priv->rtc)
|
||||
rtc_device_unregister(priv->rtc);
|
||||
if (priv->rtcregs)
|
||||
iounmap(priv->rtcregs);
|
||||
if (priv->baseaddr)
|
||||
release_mem_region(priv->baseaddr, priv->size);
|
||||
kfree(priv);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int ds1286_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct ds1286_priv *priv = platform_get_drvdata(pdev);
|
||||
|
||||
rtc_device_unregister(priv->rtc);
|
||||
iounmap(priv->rtcregs);
|
||||
release_mem_region(priv->baseaddr, priv->size);
|
||||
kfree(priv);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -224,7 +224,7 @@ static int __init ds1302_rtc_probe(struct platform_device *pdev)
|
|||
return -ENODEV;
|
||||
}
|
||||
|
||||
rtc = rtc_device_register("ds1302", &pdev->dev,
|
||||
rtc = devm_rtc_device_register(&pdev->dev, "ds1302",
|
||||
&ds1302_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
|
@ -234,11 +234,8 @@ static int __init ds1302_rtc_probe(struct platform_device *pdev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int ds1302_rtc_remove(struct platform_device *pdev)
|
||||
static int __exit ds1302_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct rtc_device *rtc = platform_get_drvdata(pdev);
|
||||
|
||||
rtc_device_unregister(rtc);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
|
@ -249,21 +246,10 @@ static struct platform_driver ds1302_platform_driver = {
|
|||
.name = DRV_NAME,
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
.remove = ds1302_rtc_remove,
|
||||
.remove = __exit_p(ds1302_rtc_remove),
|
||||
};
|
||||
|
||||
static int __init ds1302_rtc_init(void)
|
||||
{
|
||||
return platform_driver_probe(&ds1302_platform_driver, ds1302_rtc_probe);
|
||||
}
|
||||
|
||||
static void __exit ds1302_rtc_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&ds1302_platform_driver);
|
||||
}
|
||||
|
||||
module_init(ds1302_rtc_init);
|
||||
module_exit(ds1302_rtc_exit);
|
||||
module_platform_driver_probe(ds1302_platform_driver, ds1302_rtc_probe);
|
||||
|
||||
MODULE_DESCRIPTION("Dallas DS1302 RTC driver");
|
||||
MODULE_VERSION(DRV_VERSION);
|
||||
|
|
|
@ -619,7 +619,7 @@ static int ds1305_probe(struct spi_device *spi)
|
|||
return -EINVAL;
|
||||
|
||||
/* set up driver data */
|
||||
ds1305 = kzalloc(sizeof *ds1305, GFP_KERNEL);
|
||||
ds1305 = devm_kzalloc(&spi->dev, sizeof(*ds1305), GFP_KERNEL);
|
||||
if (!ds1305)
|
||||
return -ENOMEM;
|
||||
ds1305->spi = spi;
|
||||
|
@ -632,7 +632,7 @@ static int ds1305_probe(struct spi_device *spi)
|
|||
if (status < 0) {
|
||||
dev_dbg(&spi->dev, "can't %s, %d\n",
|
||||
"read", status);
|
||||
goto fail0;
|
||||
return status;
|
||||
}
|
||||
|
||||
dev_dbg(&spi->dev, "ctrl %s: %3ph\n", "read", ds1305->ctrl);
|
||||
|
@ -644,8 +644,7 @@ static int ds1305_probe(struct spi_device *spi)
|
|||
*/
|
||||
if ((ds1305->ctrl[0] & 0x38) != 0 || (ds1305->ctrl[1] & 0xfc) != 0) {
|
||||
dev_dbg(&spi->dev, "RTC chip is not present\n");
|
||||
status = -ENODEV;
|
||||
goto fail0;
|
||||
return -ENODEV;
|
||||
}
|
||||
if (ds1305->ctrl[2] == 0)
|
||||
dev_dbg(&spi->dev, "chip may not be present\n");
|
||||
|
@ -664,7 +663,7 @@ static int ds1305_probe(struct spi_device *spi)
|
|||
|
||||
dev_dbg(&spi->dev, "clear WP --> %d\n", status);
|
||||
if (status < 0)
|
||||
goto fail0;
|
||||
return status;
|
||||
}
|
||||
|
||||
/* on DS1305, maybe start oscillator; like most low power
|
||||
|
@ -718,7 +717,7 @@ static int ds1305_probe(struct spi_device *spi)
|
|||
if (status < 0) {
|
||||
dev_dbg(&spi->dev, "can't %s, %d\n",
|
||||
"write", status);
|
||||
goto fail0;
|
||||
return status;
|
||||
}
|
||||
|
||||
dev_dbg(&spi->dev, "ctrl %s: %3ph\n", "write", ds1305->ctrl);
|
||||
|
@ -730,7 +729,7 @@ static int ds1305_probe(struct spi_device *spi)
|
|||
&value, sizeof value);
|
||||
if (status < 0) {
|
||||
dev_dbg(&spi->dev, "read HOUR --> %d\n", status);
|
||||
goto fail0;
|
||||
return status;
|
||||
}
|
||||
|
||||
ds1305->hr12 = (DS1305_HR_12 & value) != 0;
|
||||
|
@ -738,12 +737,12 @@ static int ds1305_probe(struct spi_device *spi)
|
|||
dev_dbg(&spi->dev, "AM/PM\n");
|
||||
|
||||
/* register RTC ... from here on, ds1305->ctrl needs locking */
|
||||
ds1305->rtc = rtc_device_register("ds1305", &spi->dev,
|
||||
ds1305->rtc = devm_rtc_device_register(&spi->dev, "ds1305",
|
||||
&ds1305_ops, THIS_MODULE);
|
||||
if (IS_ERR(ds1305->rtc)) {
|
||||
status = PTR_ERR(ds1305->rtc);
|
||||
dev_dbg(&spi->dev, "register rtc --> %d\n", status);
|
||||
goto fail0;
|
||||
return status;
|
||||
}
|
||||
|
||||
/* Maybe set up alarm IRQ; be ready to handle it triggering right
|
||||
|
@ -754,12 +753,12 @@ static int ds1305_probe(struct spi_device *spi)
|
|||
*/
|
||||
if (spi->irq) {
|
||||
INIT_WORK(&ds1305->work, ds1305_work);
|
||||
status = request_irq(spi->irq, ds1305_irq,
|
||||
status = devm_request_irq(&spi->dev, spi->irq, ds1305_irq,
|
||||
0, dev_name(&ds1305->rtc->dev), ds1305);
|
||||
if (status < 0) {
|
||||
dev_dbg(&spi->dev, "request_irq %d --> %d\n",
|
||||
spi->irq, status);
|
||||
goto fail1;
|
||||
return status;
|
||||
}
|
||||
|
||||
device_set_wakeup_capable(&spi->dev, 1);
|
||||
|
@ -769,18 +768,10 @@ static int ds1305_probe(struct spi_device *spi)
|
|||
status = sysfs_create_bin_file(&spi->dev.kobj, &nvram);
|
||||
if (status < 0) {
|
||||
dev_dbg(&spi->dev, "register nvram --> %d\n", status);
|
||||
goto fail2;
|
||||
return status;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
fail2:
|
||||
free_irq(spi->irq, ds1305);
|
||||
fail1:
|
||||
rtc_device_unregister(ds1305->rtc);
|
||||
fail0:
|
||||
kfree(ds1305);
|
||||
return status;
|
||||
}
|
||||
|
||||
static int ds1305_remove(struct spi_device *spi)
|
||||
|
@ -792,13 +783,11 @@ static int ds1305_remove(struct spi_device *spi)
|
|||
/* carefully shut down irq and workqueue, if present */
|
||||
if (spi->irq) {
|
||||
set_bit(FLAG_EXITING, &ds1305->flags);
|
||||
free_irq(spi->irq, ds1305);
|
||||
devm_free_irq(&spi->dev, spi->irq, ds1305);
|
||||
cancel_work_sync(&ds1305->work);
|
||||
}
|
||||
|
||||
rtc_device_unregister(ds1305->rtc);
|
||||
spi_set_drvdata(spi, NULL);
|
||||
kfree(ds1305);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -4,6 +4,7 @@
|
|||
* Copyright (C) 2005 James Chapman (ds1337 core)
|
||||
* Copyright (C) 2006 David Brownell
|
||||
* Copyright (C) 2009 Matthias Fuchs (rx8025 support)
|
||||
* Copyright (C) 2012 Bertrand Achard (nvram access fixes)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
|
@ -196,7 +197,7 @@ static s32 ds1307_read_block_data_once(const struct i2c_client *client,
|
|||
static s32 ds1307_read_block_data(const struct i2c_client *client, u8 command,
|
||||
u8 length, u8 *values)
|
||||
{
|
||||
u8 oldvalues[I2C_SMBUS_BLOCK_MAX];
|
||||
u8 oldvalues[255];
|
||||
s32 ret;
|
||||
int tries = 0;
|
||||
|
||||
|
@ -222,7 +223,7 @@ static s32 ds1307_read_block_data(const struct i2c_client *client, u8 command,
|
|||
static s32 ds1307_write_block_data(const struct i2c_client *client, u8 command,
|
||||
u8 length, const u8 *values)
|
||||
{
|
||||
u8 currvalues[I2C_SMBUS_BLOCK_MAX];
|
||||
u8 currvalues[255];
|
||||
int tries = 0;
|
||||
|
||||
dev_dbg(&client->dev, "ds1307_write_block_data (length=%d)\n", length);
|
||||
|
@ -250,6 +251,57 @@ static s32 ds1307_write_block_data(const struct i2c_client *client, u8 command,
|
|||
|
||||
/*----------------------------------------------------------------------*/
|
||||
|
||||
/* These RTC devices are not designed to be connected to a SMbus adapter.
|
||||
SMbus limits block operations length to 32 bytes, whereas it's not
|
||||
limited on I2C buses. As a result, accesses may exceed 32 bytes;
|
||||
in that case, split them into smaller blocks */
|
||||
|
||||
static s32 ds1307_native_smbus_write_block_data(const struct i2c_client *client,
|
||||
u8 command, u8 length, const u8 *values)
|
||||
{
|
||||
u8 suboffset = 0;
|
||||
|
||||
if (length <= I2C_SMBUS_BLOCK_MAX)
|
||||
return i2c_smbus_write_i2c_block_data(client,
|
||||
command, length, values);
|
||||
|
||||
while (suboffset < length) {
|
||||
s32 retval = i2c_smbus_write_i2c_block_data(client,
|
||||
command + suboffset,
|
||||
min(I2C_SMBUS_BLOCK_MAX, length - suboffset),
|
||||
values + suboffset);
|
||||
if (retval < 0)
|
||||
return retval;
|
||||
|
||||
suboffset += I2C_SMBUS_BLOCK_MAX;
|
||||
}
|
||||
return length;
|
||||
}
|
||||
|
||||
static s32 ds1307_native_smbus_read_block_data(const struct i2c_client *client,
|
||||
u8 command, u8 length, u8 *values)
|
||||
{
|
||||
u8 suboffset = 0;
|
||||
|
||||
if (length <= I2C_SMBUS_BLOCK_MAX)
|
||||
return i2c_smbus_read_i2c_block_data(client,
|
||||
command, length, values);
|
||||
|
||||
while (suboffset < length) {
|
||||
s32 retval = i2c_smbus_read_i2c_block_data(client,
|
||||
command + suboffset,
|
||||
min(I2C_SMBUS_BLOCK_MAX, length - suboffset),
|
||||
values + suboffset);
|
||||
if (retval < 0)
|
||||
return retval;
|
||||
|
||||
suboffset += I2C_SMBUS_BLOCK_MAX;
|
||||
}
|
||||
return length;
|
||||
}
|
||||
|
||||
/*----------------------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* The IRQ logic includes a "real" handler running in IRQ context just
|
||||
* long enough to schedule this workqueue entry. We need a task context
|
||||
|
@ -646,8 +698,8 @@ static int ds1307_probe(struct i2c_client *client,
|
|||
|
||||
buf = ds1307->regs;
|
||||
if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
|
||||
ds1307->read_block_data = i2c_smbus_read_i2c_block_data;
|
||||
ds1307->write_block_data = i2c_smbus_write_i2c_block_data;
|
||||
ds1307->read_block_data = ds1307_native_smbus_read_block_data;
|
||||
ds1307->write_block_data = ds1307_native_smbus_write_block_data;
|
||||
} else {
|
||||
ds1307->read_block_data = ds1307_read_block_data;
|
||||
ds1307->write_block_data = ds1307_write_block_data;
|
||||
|
@ -661,7 +713,7 @@ static int ds1307_probe(struct i2c_client *client,
|
|||
tmp = ds1307->read_block_data(ds1307->client,
|
||||
DS1337_REG_CONTROL, 2, buf);
|
||||
if (tmp != 2) {
|
||||
pr_debug("read error %d\n", tmp);
|
||||
dev_dbg(&client->dev, "read error %d\n", tmp);
|
||||
err = -EIO;
|
||||
goto exit_free;
|
||||
}
|
||||
|
@ -700,7 +752,7 @@ static int ds1307_probe(struct i2c_client *client,
|
|||
tmp = i2c_smbus_read_i2c_block_data(ds1307->client,
|
||||
RX8025_REG_CTRL1 << 4 | 0x08, 2, buf);
|
||||
if (tmp != 2) {
|
||||
pr_debug("read error %d\n", tmp);
|
||||
dev_dbg(&client->dev, "read error %d\n", tmp);
|
||||
err = -EIO;
|
||||
goto exit_free;
|
||||
}
|
||||
|
@ -744,7 +796,7 @@ static int ds1307_probe(struct i2c_client *client,
|
|||
tmp = i2c_smbus_read_i2c_block_data(ds1307->client,
|
||||
RX8025_REG_CTRL1 << 4 | 0x08, 2, buf);
|
||||
if (tmp != 2) {
|
||||
pr_debug("read error %d\n", tmp);
|
||||
dev_dbg(&client->dev, "read error %d\n", tmp);
|
||||
err = -EIO;
|
||||
goto exit_free;
|
||||
}
|
||||
|
@ -772,7 +824,7 @@ read_rtc:
|
|||
/* read RTC registers */
|
||||
tmp = ds1307->read_block_data(ds1307->client, ds1307->offset, 8, buf);
|
||||
if (tmp != 8) {
|
||||
pr_debug("read error %d\n", tmp);
|
||||
dev_dbg(&client->dev, "read error %d\n", tmp);
|
||||
err = -EIO;
|
||||
goto exit_free;
|
||||
}
|
||||
|
@ -814,7 +866,7 @@ read_rtc:
|
|||
|
||||
tmp = i2c_smbus_read_byte_data(client, DS1340_REG_FLAG);
|
||||
if (tmp < 0) {
|
||||
pr_debug("read error %d\n", tmp);
|
||||
dev_dbg(&client->dev, "read error %d\n", tmp);
|
||||
err = -EIO;
|
||||
goto exit_free;
|
||||
}
|
||||
|
@ -908,8 +960,8 @@ read_rtc:
|
|||
ds1307->nvram->attr.name = "nvram";
|
||||
ds1307->nvram->attr.mode = S_IRUGO | S_IWUSR;
|
||||
sysfs_bin_attr_init(ds1307->nvram);
|
||||
ds1307->nvram->read = ds1307_nvram_read,
|
||||
ds1307->nvram->write = ds1307_nvram_write,
|
||||
ds1307->nvram->read = ds1307_nvram_read;
|
||||
ds1307->nvram->write = ds1307_nvram_write;
|
||||
ds1307->nvram->size = chip->nvram_size;
|
||||
ds1307->nvram_offset = chip->nvram_offset;
|
||||
err = sysfs_create_bin_file(&client->dev.kobj, ds1307->nvram);
|
||||
|
|
|
@ -347,7 +347,7 @@ static int ds1374_probe(struct i2c_client *client,
|
|||
struct ds1374 *ds1374;
|
||||
int ret;
|
||||
|
||||
ds1374 = kzalloc(sizeof(struct ds1374), GFP_KERNEL);
|
||||
ds1374 = devm_kzalloc(&client->dev, sizeof(struct ds1374), GFP_KERNEL);
|
||||
if (!ds1374)
|
||||
return -ENOMEM;
|
||||
|
||||
|
@ -359,36 +359,27 @@ static int ds1374_probe(struct i2c_client *client,
|
|||
|
||||
ret = ds1374_check_rtc_status(client);
|
||||
if (ret)
|
||||
goto out_free;
|
||||
return ret;
|
||||
|
||||
if (client->irq > 0) {
|
||||
ret = request_irq(client->irq, ds1374_irq, 0,
|
||||
ret = devm_request_irq(&client->dev, client->irq, ds1374_irq, 0,
|
||||
"ds1374", client);
|
||||
if (ret) {
|
||||
dev_err(&client->dev, "unable to request IRQ\n");
|
||||
goto out_free;
|
||||
return ret;
|
||||
}
|
||||
|
||||
device_set_wakeup_capable(&client->dev, 1);
|
||||
}
|
||||
|
||||
ds1374->rtc = rtc_device_register(client->name, &client->dev,
|
||||
ds1374->rtc = devm_rtc_device_register(&client->dev, client->name,
|
||||
&ds1374_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(ds1374->rtc)) {
|
||||
ret = PTR_ERR(ds1374->rtc);
|
||||
dev_err(&client->dev, "unable to register the class device\n");
|
||||
goto out_irq;
|
||||
return PTR_ERR(ds1374->rtc);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
out_irq:
|
||||
if (client->irq > 0)
|
||||
free_irq(client->irq, client);
|
||||
|
||||
out_free:
|
||||
kfree(ds1374);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int ds1374_remove(struct i2c_client *client)
|
||||
|
@ -400,16 +391,14 @@ static int ds1374_remove(struct i2c_client *client)
|
|||
ds1374->exiting = 1;
|
||||
mutex_unlock(&ds1374->mutex);
|
||||
|
||||
free_irq(client->irq, client);
|
||||
devm_free_irq(&client->dev, client->irq, client);
|
||||
cancel_work_sync(&ds1374->work);
|
||||
}
|
||||
|
||||
rtc_device_unregister(ds1374->rtc);
|
||||
kfree(ds1374);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
static int ds1374_suspend(struct device *dev)
|
||||
{
|
||||
struct i2c_client *client = to_i2c_client(dev);
|
||||
|
@ -427,19 +416,15 @@ static int ds1374_resume(struct device *dev)
|
|||
disable_irq_wake(client->irq);
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static SIMPLE_DEV_PM_OPS(ds1374_pm, ds1374_suspend, ds1374_resume);
|
||||
|
||||
#define DS1374_PM (&ds1374_pm)
|
||||
#else
|
||||
#define DS1374_PM NULL
|
||||
#endif
|
||||
|
||||
static struct i2c_driver ds1374_driver = {
|
||||
.driver = {
|
||||
.name = "rtc-ds1374",
|
||||
.owner = THIS_MODULE,
|
||||
.pm = DS1374_PM,
|
||||
.pm = &ds1374_pm,
|
||||
},
|
||||
.probe = ds1374_probe,
|
||||
.remove = ds1374_remove,
|
||||
|
|
|
@ -131,26 +131,24 @@ static int ds1390_probe(struct spi_device *spi)
|
|||
spi->bits_per_word = 8;
|
||||
spi_setup(spi);
|
||||
|
||||
chip = kzalloc(sizeof *chip, GFP_KERNEL);
|
||||
chip = devm_kzalloc(&spi->dev, sizeof(*chip), GFP_KERNEL);
|
||||
if (!chip) {
|
||||
dev_err(&spi->dev, "unable to allocate device memory\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
dev_set_drvdata(&spi->dev, chip);
|
||||
spi_set_drvdata(spi, chip);
|
||||
|
||||
res = ds1390_get_reg(&spi->dev, DS1390_REG_SECONDS, &tmp);
|
||||
if (res != 0) {
|
||||
dev_err(&spi->dev, "unable to read device\n");
|
||||
kfree(chip);
|
||||
return res;
|
||||
}
|
||||
|
||||
chip->rtc = rtc_device_register("ds1390",
|
||||
&spi->dev, &ds1390_rtc_ops, THIS_MODULE);
|
||||
chip->rtc = devm_rtc_device_register(&spi->dev, "ds1390",
|
||||
&ds1390_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(chip->rtc)) {
|
||||
dev_err(&spi->dev, "unable to register device\n");
|
||||
res = PTR_ERR(chip->rtc);
|
||||
kfree(chip);
|
||||
}
|
||||
|
||||
return res;
|
||||
|
@ -158,11 +156,6 @@ static int ds1390_probe(struct spi_device *spi)
|
|||
|
||||
static int ds1390_remove(struct spi_device *spi)
|
||||
{
|
||||
struct ds1390 *chip = spi_get_drvdata(spi);
|
||||
|
||||
rtc_device_unregister(chip->rtc);
|
||||
kfree(chip);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -538,15 +538,14 @@ static int ds1511_rtc_probe(struct platform_device *pdev)
|
|||
}
|
||||
}
|
||||
|
||||
rtc = rtc_device_register(pdev->name, &pdev->dev, &ds1511_rtc_ops,
|
||||
THIS_MODULE);
|
||||
rtc = devm_rtc_device_register(&pdev->dev, pdev->name, &ds1511_rtc_ops,
|
||||
THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
pdata->rtc = rtc;
|
||||
|
||||
ret = sysfs_create_bin_file(&pdev->dev.kobj, &ds1511_nvram_attr);
|
||||
if (ret)
|
||||
rtc_device_unregister(pdata->rtc);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -555,7 +554,6 @@ static int ds1511_rtc_remove(struct platform_device *pdev)
|
|||
struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
|
||||
|
||||
sysfs_remove_bin_file(&pdev->dev.kobj, &ds1511_nvram_attr);
|
||||
rtc_device_unregister(pdata->rtc);
|
||||
if (pdata->irq > 0) {
|
||||
/*
|
||||
* disable the alarm interrupt
|
||||
|
|
|
@ -326,15 +326,14 @@ static int ds1553_rtc_probe(struct platform_device *pdev)
|
|||
}
|
||||
}
|
||||
|
||||
rtc = rtc_device_register(pdev->name, &pdev->dev,
|
||||
rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&ds1553_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
pdata->rtc = rtc;
|
||||
|
||||
ret = sysfs_create_bin_file(&pdev->dev.kobj, &ds1553_nvram_attr);
|
||||
if (ret)
|
||||
rtc_device_unregister(rtc);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -343,7 +342,6 @@ static int ds1553_rtc_remove(struct platform_device *pdev)
|
|||
struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
|
||||
|
||||
sysfs_remove_bin_file(&pdev->dev.kobj, &ds1553_nvram_attr);
|
||||
rtc_device_unregister(pdata->rtc);
|
||||
if (pdata->irq > 0)
|
||||
writeb(0, pdata->ioaddr + RTC_INTERRUPTS);
|
||||
return 0;
|
||||
|
|
|
@ -155,11 +155,6 @@ static const struct rtc_class_ops ds1672_rtc_ops = {
|
|||
|
||||
static int ds1672_remove(struct i2c_client *client)
|
||||
{
|
||||
struct rtc_device *rtc = i2c_get_clientdata(client);
|
||||
|
||||
if (rtc)
|
||||
rtc_device_unregister(rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -177,7 +172,7 @@ static int ds1672_probe(struct i2c_client *client,
|
|||
|
||||
dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
|
||||
|
||||
rtc = rtc_device_register(ds1672_driver.driver.name, &client->dev,
|
||||
rtc = devm_rtc_device_register(&client->dev, ds1672_driver.driver.name,
|
||||
&ds1672_rtc_ops, THIS_MODULE);
|
||||
|
||||
if (IS_ERR(rtc))
|
||||
|
@ -202,7 +197,6 @@ static int ds1672_probe(struct i2c_client *client,
|
|||
return 0;
|
||||
|
||||
exit_devreg:
|
||||
rtc_device_unregister(rtc);
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
|
@ -208,17 +208,14 @@ static int ds1742_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
pdata->last_jiffies = jiffies;
|
||||
platform_set_drvdata(pdev, pdata);
|
||||
rtc = rtc_device_register(pdev->name, &pdev->dev,
|
||||
rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&ds1742_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
pdata->rtc = rtc;
|
||||
|
||||
ret = sysfs_create_bin_file(&pdev->dev.kobj, &pdata->nvram_attr);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "creating nvram file in sysfs failed\n");
|
||||
rtc_device_unregister(rtc);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -227,7 +224,6 @@ static int ds1742_rtc_remove(struct platform_device *pdev)
|
|||
struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
|
||||
|
||||
sysfs_remove_bin_file(&pdev->dev.kobj, &pdata->nvram_attr);
|
||||
rtc_device_unregister(pdata->rtc);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -228,7 +228,7 @@ static int rtc_probe(struct platform_device *pdev)
|
|||
struct ds2404 *chip;
|
||||
int retval = -EBUSY;
|
||||
|
||||
chip = kzalloc(sizeof(struct ds2404), GFP_KERNEL);
|
||||
chip = devm_kzalloc(&pdev->dev, sizeof(struct ds2404), GFP_KERNEL);
|
||||
if (!chip)
|
||||
return -ENOMEM;
|
||||
|
||||
|
@ -244,8 +244,8 @@ static int rtc_probe(struct platform_device *pdev)
|
|||
|
||||
platform_set_drvdata(pdev, chip);
|
||||
|
||||
chip->rtc = rtc_device_register("ds2404",
|
||||
&pdev->dev, &ds2404_rtc_ops, THIS_MODULE);
|
||||
chip->rtc = devm_rtc_device_register(&pdev->dev, "ds2404",
|
||||
&ds2404_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(chip->rtc)) {
|
||||
retval = PTR_ERR(chip->rtc);
|
||||
goto err_io;
|
||||
|
@ -257,20 +257,14 @@ static int rtc_probe(struct platform_device *pdev)
|
|||
err_io:
|
||||
chip->ops->unmap_io(chip);
|
||||
err_chip:
|
||||
kfree(chip);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static int rtc_remove(struct platform_device *dev)
|
||||
{
|
||||
struct ds2404 *chip = platform_get_drvdata(dev);
|
||||
struct rtc_device *rtc = chip->rtc;
|
||||
|
||||
if (rtc)
|
||||
rtc_device_unregister(rtc);
|
||||
|
||||
chip->ops->unmap_io(chip);
|
||||
kfree(chip);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -397,7 +397,7 @@ static int ds3232_probe(struct i2c_client *client,
|
|||
struct ds3232 *ds3232;
|
||||
int ret;
|
||||
|
||||
ds3232 = kzalloc(sizeof(struct ds3232), GFP_KERNEL);
|
||||
ds3232 = devm_kzalloc(&client->dev, sizeof(struct ds3232), GFP_KERNEL);
|
||||
if (!ds3232)
|
||||
return -ENOMEM;
|
||||
|
||||
|
@ -409,34 +409,25 @@ static int ds3232_probe(struct i2c_client *client,
|
|||
|
||||
ret = ds3232_check_rtc_status(client);
|
||||
if (ret)
|
||||
goto out_free;
|
||||
return ret;
|
||||
|
||||
ds3232->rtc = rtc_device_register(client->name, &client->dev,
|
||||
ds3232->rtc = devm_rtc_device_register(&client->dev, client->name,
|
||||
&ds3232_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(ds3232->rtc)) {
|
||||
ret = PTR_ERR(ds3232->rtc);
|
||||
dev_err(&client->dev, "unable to register the class device\n");
|
||||
goto out_irq;
|
||||
return PTR_ERR(ds3232->rtc);
|
||||
}
|
||||
|
||||
if (client->irq >= 0) {
|
||||
ret = request_irq(client->irq, ds3232_irq, 0,
|
||||
ret = devm_request_irq(&client->dev, client->irq, ds3232_irq, 0,
|
||||
"ds3232", client);
|
||||
if (ret) {
|
||||
dev_err(&client->dev, "unable to request IRQ\n");
|
||||
goto out_free;
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
out_irq:
|
||||
if (client->irq >= 0)
|
||||
free_irq(client->irq, client);
|
||||
|
||||
out_free:
|
||||
kfree(ds3232);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int ds3232_remove(struct i2c_client *client)
|
||||
|
@ -448,12 +439,10 @@ static int ds3232_remove(struct i2c_client *client)
|
|||
ds3232->exiting = 1;
|
||||
mutex_unlock(&ds3232->mutex);
|
||||
|
||||
free_irq(client->irq, client);
|
||||
devm_free_irq(&client->dev, client->irq, client);
|
||||
cancel_work_sync(&ds3232->work);
|
||||
}
|
||||
|
||||
rtc_device_unregister(ds3232->rtc);
|
||||
kfree(ds3232);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -146,21 +146,18 @@ static int ds3234_probe(struct spi_device *spi)
|
|||
ds3234_get_reg(&spi->dev, DS3234_REG_CONT_STAT, &tmp);
|
||||
dev_info(&spi->dev, "Ctrl/Stat Reg: 0x%02x\n", tmp);
|
||||
|
||||
rtc = rtc_device_register("ds3234",
|
||||
&spi->dev, &ds3234_rtc_ops, THIS_MODULE);
|
||||
rtc = devm_rtc_device_register(&spi->dev, "ds3234",
|
||||
&ds3234_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
|
||||
dev_set_drvdata(&spi->dev, rtc);
|
||||
spi_set_drvdata(spi, rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ds3234_remove(struct spi_device *spi)
|
||||
{
|
||||
struct rtc_device *rtc = spi_get_drvdata(spi);
|
||||
|
||||
rtc_device_unregister(rtc);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -191,7 +191,7 @@ static int __init efi_rtc_probe(struct platform_device *dev)
|
|||
{
|
||||
struct rtc_device *rtc;
|
||||
|
||||
rtc = rtc_device_register("rtc-efi", &dev->dev, &efi_rtc_ops,
|
||||
rtc = devm_rtc_device_register(&dev->dev, "rtc-efi", &efi_rtc_ops,
|
||||
THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
|
@ -203,10 +203,6 @@ static int __init efi_rtc_probe(struct platform_device *dev)
|
|||
|
||||
static int __exit efi_rtc_remove(struct platform_device *dev)
|
||||
{
|
||||
struct rtc_device *rtc = platform_get_drvdata(dev);
|
||||
|
||||
rtc_device_unregister(rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -218,18 +214,7 @@ static struct platform_driver efi_rtc_driver = {
|
|||
.remove = __exit_p(efi_rtc_remove),
|
||||
};
|
||||
|
||||
static int __init efi_rtc_init(void)
|
||||
{
|
||||
return platform_driver_probe(&efi_rtc_driver, efi_rtc_probe);
|
||||
}
|
||||
|
||||
static void __exit efi_rtc_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&efi_rtc_driver);
|
||||
}
|
||||
|
||||
module_init(efi_rtc_init);
|
||||
module_exit(efi_rtc_exit);
|
||||
module_platform_driver_probe(efi_rtc_driver, efi_rtc_probe);
|
||||
|
||||
MODULE_AUTHOR("dann frazier <dannf@hp.com>");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
|
|
@ -121,7 +121,7 @@ static int em3027_probe(struct i2c_client *client,
|
|||
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
|
||||
return -ENODEV;
|
||||
|
||||
rtc = rtc_device_register(em3027_driver.driver.name, &client->dev,
|
||||
rtc = devm_rtc_device_register(&client->dev, em3027_driver.driver.name,
|
||||
&em3027_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
|
@ -133,11 +133,6 @@ static int em3027_probe(struct i2c_client *client,
|
|||
|
||||
static int em3027_remove(struct i2c_client *client)
|
||||
{
|
||||
struct rtc_device *rtc = i2c_get_clientdata(client);
|
||||
|
||||
if (rtc)
|
||||
rtc_device_unregister(rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -153,8 +153,8 @@ static int ep93xx_rtc_probe(struct platform_device *pdev)
|
|||
pdev->dev.platform_data = ep93xx_rtc;
|
||||
platform_set_drvdata(pdev, ep93xx_rtc);
|
||||
|
||||
ep93xx_rtc->rtc = rtc_device_register(pdev->name,
|
||||
&pdev->dev, &ep93xx_rtc_ops, THIS_MODULE);
|
||||
ep93xx_rtc->rtc = devm_rtc_device_register(&pdev->dev,
|
||||
pdev->name, &ep93xx_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(ep93xx_rtc->rtc)) {
|
||||
err = PTR_ERR(ep93xx_rtc->rtc);
|
||||
goto exit;
|
||||
|
@ -162,12 +162,10 @@ static int ep93xx_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
err = sysfs_create_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
|
||||
if (err)
|
||||
goto fail;
|
||||
goto exit;
|
||||
|
||||
return 0;
|
||||
|
||||
fail:
|
||||
rtc_device_unregister(ep93xx_rtc->rtc);
|
||||
exit:
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
pdev->dev.platform_data = NULL;
|
||||
|
@ -176,11 +174,8 @@ exit:
|
|||
|
||||
static int ep93xx_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct ep93xx_rtc *ep93xx_rtc = platform_get_drvdata(pdev);
|
||||
|
||||
sysfs_remove_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
rtc_device_unregister(ep93xx_rtc->rtc);
|
||||
pdev->dev.platform_data = NULL;
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -358,7 +358,7 @@ static int fm3130_probe(struct i2c_client *client,
|
|||
I2C_FUNC_I2C | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
|
||||
return -EIO;
|
||||
|
||||
fm3130 = kzalloc(sizeof(struct fm3130), GFP_KERNEL);
|
||||
fm3130 = devm_kzalloc(&client->dev, sizeof(struct fm3130), GFP_KERNEL);
|
||||
|
||||
if (!fm3130)
|
||||
return -ENOMEM;
|
||||
|
@ -395,7 +395,7 @@ static int fm3130_probe(struct i2c_client *client,
|
|||
|
||||
tmp = i2c_transfer(adapter, fm3130->msg, 4);
|
||||
if (tmp != 4) {
|
||||
pr_debug("read error %d\n", tmp);
|
||||
dev_dbg(&client->dev, "read error %d\n", tmp);
|
||||
err = -EIO;
|
||||
goto exit_free;
|
||||
}
|
||||
|
@ -507,7 +507,7 @@ bad_clock:
|
|||
|
||||
/* We won't bail out here because we just got invalid data.
|
||||
Time setting from u-boot doesn't work anyway */
|
||||
fm3130->rtc = rtc_device_register(client->name, &client->dev,
|
||||
fm3130->rtc = devm_rtc_device_register(&client->dev, client->name,
|
||||
&fm3130_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(fm3130->rtc)) {
|
||||
err = PTR_ERR(fm3130->rtc);
|
||||
|
@ -517,16 +517,11 @@ bad_clock:
|
|||
}
|
||||
return 0;
|
||||
exit_free:
|
||||
kfree(fm3130);
|
||||
return err;
|
||||
}
|
||||
|
||||
static int fm3130_remove(struct i2c_client *client)
|
||||
{
|
||||
struct fm3130 *fm3130 = i2c_get_clientdata(client);
|
||||
|
||||
rtc_device_unregister(fm3130->rtc);
|
||||
kfree(fm3130);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -38,8 +38,8 @@ static int __init generic_rtc_probe(struct platform_device *dev)
|
|||
{
|
||||
struct rtc_device *rtc;
|
||||
|
||||
rtc = rtc_device_register("rtc-generic", &dev->dev, &generic_rtc_ops,
|
||||
THIS_MODULE);
|
||||
rtc = devm_rtc_device_register(&dev->dev, "rtc-generic",
|
||||
&generic_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
|
||||
|
@ -50,10 +50,6 @@ static int __init generic_rtc_probe(struct platform_device *dev)
|
|||
|
||||
static int __exit generic_rtc_remove(struct platform_device *dev)
|
||||
{
|
||||
struct rtc_device *rtc = platform_get_drvdata(dev);
|
||||
|
||||
rtc_device_unregister(rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -65,18 +61,7 @@ static struct platform_driver generic_rtc_driver = {
|
|||
.remove = __exit_p(generic_rtc_remove),
|
||||
};
|
||||
|
||||
static int __init generic_rtc_init(void)
|
||||
{
|
||||
return platform_driver_probe(&generic_rtc_driver, generic_rtc_probe);
|
||||
}
|
||||
|
||||
static void __exit generic_rtc_fini(void)
|
||||
{
|
||||
platform_driver_unregister(&generic_rtc_driver);
|
||||
}
|
||||
|
||||
module_init(generic_rtc_init);
|
||||
module_exit(generic_rtc_fini);
|
||||
module_platform_driver_probe(generic_rtc_driver, generic_rtc_probe);
|
||||
|
||||
MODULE_AUTHOR("Kyle McMartin <kyle@mcmartin.ca>");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
|
|
@ -255,8 +255,9 @@ static int hid_time_probe(struct platform_device *pdev)
|
|||
return ret;
|
||||
}
|
||||
|
||||
time_state->rtc = rtc_device_register("hid-sensor-time",
|
||||
&pdev->dev, &hid_time_rtc_ops, THIS_MODULE);
|
||||
time_state->rtc = devm_rtc_device_register(&pdev->dev,
|
||||
"hid-sensor-time", &hid_time_rtc_ops,
|
||||
THIS_MODULE);
|
||||
|
||||
if (IS_ERR(time_state->rtc)) {
|
||||
dev_err(&pdev->dev, "rtc device register failed!\n");
|
||||
|
@ -269,9 +270,7 @@ static int hid_time_probe(struct platform_device *pdev)
|
|||
static int hid_time_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
|
||||
struct hid_time_state *time_state = platform_get_drvdata(pdev);
|
||||
|
||||
rtc_device_unregister(time_state->rtc);
|
||||
sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_TIME);
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -369,7 +369,7 @@ static void dryice_work(struct work_struct *work)
|
|||
/*
|
||||
* probe for dryice rtc device
|
||||
*/
|
||||
static int dryice_rtc_probe(struct platform_device *pdev)
|
||||
static int __init dryice_rtc_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct resource *res;
|
||||
struct imxdi_dev *imxdi;
|
||||
|
@ -464,7 +464,7 @@ static int dryice_rtc_probe(struct platform_device *pdev)
|
|||
}
|
||||
|
||||
platform_set_drvdata(pdev, imxdi);
|
||||
imxdi->rtc = rtc_device_register(pdev->name, &pdev->dev,
|
||||
imxdi->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&dryice_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(imxdi->rtc)) {
|
||||
rc = PTR_ERR(imxdi->rtc);
|
||||
|
@ -479,7 +479,7 @@ err:
|
|||
return rc;
|
||||
}
|
||||
|
||||
static int dryice_rtc_remove(struct platform_device *pdev)
|
||||
static int __exit dryice_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct imxdi_dev *imxdi = platform_get_drvdata(pdev);
|
||||
|
||||
|
@ -488,8 +488,6 @@ static int dryice_rtc_remove(struct platform_device *pdev)
|
|||
/* mask all interrupts */
|
||||
__raw_writel(0, imxdi->ioaddr + DIER);
|
||||
|
||||
rtc_device_unregister(imxdi->rtc);
|
||||
|
||||
clk_disable_unprepare(imxdi->clk);
|
||||
|
||||
return 0;
|
||||
|
@ -510,21 +508,10 @@ static struct platform_driver dryice_rtc_driver = {
|
|||
.owner = THIS_MODULE,
|
||||
.of_match_table = of_match_ptr(dryice_dt_ids),
|
||||
},
|
||||
.remove = dryice_rtc_remove,
|
||||
.remove = __exit_p(dryice_rtc_remove),
|
||||
};
|
||||
|
||||
static int __init dryice_rtc_init(void)
|
||||
{
|
||||
return platform_driver_probe(&dryice_rtc_driver, dryice_rtc_probe);
|
||||
}
|
||||
|
||||
static void __exit dryice_rtc_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&dryice_rtc_driver);
|
||||
}
|
||||
|
||||
module_init(dryice_rtc_init);
|
||||
module_exit(dryice_rtc_exit);
|
||||
module_platform_driver_probe(dryice_rtc_driver, dryice_rtc_probe);
|
||||
|
||||
MODULE_AUTHOR("Freescale Semiconductor, Inc.");
|
||||
MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
|
||||
|
|
|
@ -252,12 +252,11 @@ static int isl12022_probe(struct i2c_client *client,
|
|||
{
|
||||
struct isl12022 *isl12022;
|
||||
|
||||
int ret = 0;
|
||||
|
||||
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
|
||||
return -ENODEV;
|
||||
|
||||
isl12022 = kzalloc(sizeof(struct isl12022), GFP_KERNEL);
|
||||
isl12022 = devm_kzalloc(&client->dev, sizeof(struct isl12022),
|
||||
GFP_KERNEL);
|
||||
if (!isl12022)
|
||||
return -ENOMEM;
|
||||
|
||||
|
@ -265,37 +264,22 @@ static int isl12022_probe(struct i2c_client *client,
|
|||
|
||||
i2c_set_clientdata(client, isl12022);
|
||||
|
||||
isl12022->rtc = rtc_device_register(isl12022_driver.driver.name,
|
||||
&client->dev,
|
||||
&isl12022_rtc_ops,
|
||||
THIS_MODULE);
|
||||
|
||||
if (IS_ERR(isl12022->rtc)) {
|
||||
ret = PTR_ERR(isl12022->rtc);
|
||||
goto exit_kfree;
|
||||
}
|
||||
isl12022->rtc = devm_rtc_device_register(&client->dev,
|
||||
isl12022_driver.driver.name,
|
||||
&isl12022_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(isl12022->rtc))
|
||||
return PTR_ERR(isl12022->rtc);
|
||||
|
||||
return 0;
|
||||
|
||||
exit_kfree:
|
||||
kfree(isl12022);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int isl12022_remove(struct i2c_client *client)
|
||||
{
|
||||
struct isl12022 *isl12022 = i2c_get_clientdata(client);
|
||||
|
||||
rtc_device_unregister(isl12022->rtc);
|
||||
kfree(isl12022);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct i2c_device_id isl12022_id[] = {
|
||||
{ "isl12022", 0 },
|
||||
{ "rtc8564", 0 },
|
||||
{ }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(i2c, isl12022_id);
|
||||
|
|
|
@ -299,7 +299,7 @@ static int lp8788_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
device_init_wakeup(dev, 1);
|
||||
|
||||
rtc->rdev = rtc_device_register("lp8788_rtc", dev,
|
||||
rtc->rdev = devm_rtc_device_register(dev, "lp8788_rtc",
|
||||
&lp8788_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc->rdev)) {
|
||||
dev_err(dev, "can not register rtc device\n");
|
||||
|
@ -314,9 +314,6 @@ static int lp8788_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
static int lp8788_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct lp8788_rtc *rtc = platform_get_drvdata(pdev);
|
||||
|
||||
rtc_device_unregister(rtc->rdev);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -273,8 +273,8 @@ static int lpc32xx_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
platform_set_drvdata(pdev, rtc);
|
||||
|
||||
rtc->rtc = rtc_device_register(RTC_NAME, &pdev->dev, &lpc32xx_rtc_ops,
|
||||
THIS_MODULE);
|
||||
rtc->rtc = devm_rtc_device_register(&pdev->dev, RTC_NAME,
|
||||
&lpc32xx_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc->rtc)) {
|
||||
dev_err(&pdev->dev, "Can't get RTC\n");
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
@ -307,7 +307,6 @@ static int lpc32xx_rtc_remove(struct platform_device *pdev)
|
|||
device_init_wakeup(&pdev->dev, 0);
|
||||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
rtc_device_unregister(rtc->rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -172,7 +172,7 @@ static int ls1x_rtc_probe(struct platform_device *pdev)
|
|||
while (readl(SYS_COUNTER_CNTRL) & SYS_CNTRL_TTS)
|
||||
usleep_range(1000, 3000);
|
||||
|
||||
rtcdev = rtc_device_register("ls1x-rtc", &pdev->dev,
|
||||
rtcdev = devm_rtc_device_register(&pdev->dev, "ls1x-rtc",
|
||||
&ls1x_rtc_ops , THIS_MODULE);
|
||||
if (IS_ERR(rtcdev)) {
|
||||
ret = PTR_ERR(rtcdev);
|
||||
|
@ -187,9 +187,6 @@ err:
|
|||
|
||||
static int ls1x_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct rtc_device *rtcdev = platform_get_drvdata(pdev);
|
||||
|
||||
rtc_device_unregister(rtcdev);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -637,7 +637,8 @@ static int m41t80_probe(struct i2c_client *client,
|
|||
dev_info(&client->dev,
|
||||
"chip found, driver version " DRV_VERSION "\n");
|
||||
|
||||
clientdata = kzalloc(sizeof(*clientdata), GFP_KERNEL);
|
||||
clientdata = devm_kzalloc(&client->dev, sizeof(*clientdata),
|
||||
GFP_KERNEL);
|
||||
if (!clientdata) {
|
||||
rc = -ENOMEM;
|
||||
goto exit;
|
||||
|
@ -646,8 +647,8 @@ static int m41t80_probe(struct i2c_client *client,
|
|||
clientdata->features = id->driver_data;
|
||||
i2c_set_clientdata(client, clientdata);
|
||||
|
||||
rtc = rtc_device_register(client->name, &client->dev,
|
||||
&m41t80_rtc_ops, THIS_MODULE);
|
||||
rtc = devm_rtc_device_register(&client->dev, client->name,
|
||||
&m41t80_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc)) {
|
||||
rc = PTR_ERR(rtc);
|
||||
rtc = NULL;
|
||||
|
@ -718,26 +719,19 @@ ht_err:
|
|||
goto exit;
|
||||
|
||||
exit:
|
||||
if (rtc)
|
||||
rtc_device_unregister(rtc);
|
||||
kfree(clientdata);
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int m41t80_remove(struct i2c_client *client)
|
||||
{
|
||||
struct m41t80_data *clientdata = i2c_get_clientdata(client);
|
||||
struct rtc_device *rtc = clientdata->rtc;
|
||||
|
||||
#ifdef CONFIG_RTC_DRV_M41T80_WDT
|
||||
struct m41t80_data *clientdata = i2c_get_clientdata(client);
|
||||
|
||||
if (clientdata->features & M41T80_FEATURE_HT) {
|
||||
misc_deregister(&wdt_dev);
|
||||
unregister_reboot_notifier(&wdt_notifier);
|
||||
}
|
||||
#endif
|
||||
if (rtc)
|
||||
rtc_device_unregister(rtc);
|
||||
kfree(clientdata);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -184,12 +184,12 @@ static int m41t93_probe(struct spi_device *spi)
|
|||
return -ENODEV;
|
||||
}
|
||||
|
||||
rtc = rtc_device_register(m41t93_driver.driver.name,
|
||||
&spi->dev, &m41t93_rtc_ops, THIS_MODULE);
|
||||
rtc = devm_rtc_device_register(&spi->dev, m41t93_driver.driver.name,
|
||||
&m41t93_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
|
||||
dev_set_drvdata(&spi->dev, rtc);
|
||||
spi_set_drvdata(spi, rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -197,11 +197,6 @@ static int m41t93_probe(struct spi_device *spi)
|
|||
|
||||
static int m41t93_remove(struct spi_device *spi)
|
||||
{
|
||||
struct rtc_device *rtc = spi_get_drvdata(spi);
|
||||
|
||||
if (rtc)
|
||||
rtc_device_unregister(rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -124,23 +124,18 @@ static int m41t94_probe(struct spi_device *spi)
|
|||
return res;
|
||||
}
|
||||
|
||||
rtc = rtc_device_register(m41t94_driver.driver.name,
|
||||
&spi->dev, &m41t94_rtc_ops, THIS_MODULE);
|
||||
rtc = devm_rtc_device_register(&spi->dev, m41t94_driver.driver.name,
|
||||
&m41t94_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
|
||||
dev_set_drvdata(&spi->dev, rtc);
|
||||
spi_set_drvdata(spi, rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int m41t94_remove(struct spi_device *spi)
|
||||
{
|
||||
struct rtc_device *rtc = spi_get_drvdata(spi);
|
||||
|
||||
if (rtc)
|
||||
rtc_device_unregister(rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -145,12 +145,11 @@ static int m48t35_probe(struct platform_device *pdev)
|
|||
{
|
||||
struct resource *res;
|
||||
struct m48t35_priv *priv;
|
||||
int ret = 0;
|
||||
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
if (!res)
|
||||
return -ENODEV;
|
||||
priv = kzalloc(sizeof(struct m48t35_priv), GFP_KERNEL);
|
||||
priv = devm_kzalloc(&pdev->dev, sizeof(struct m48t35_priv), GFP_KERNEL);
|
||||
if (!priv)
|
||||
return -ENOMEM;
|
||||
|
||||
|
@ -160,50 +159,29 @@ static int m48t35_probe(struct platform_device *pdev)
|
|||
* conflicts are resolved
|
||||
*/
|
||||
#ifndef CONFIG_SGI_IP27
|
||||
if (!request_mem_region(res->start, priv->size, pdev->name)) {
|
||||
ret = -EBUSY;
|
||||
goto out;
|
||||
}
|
||||
if (!devm_request_mem_region(&pdev->dev, res->start, priv->size,
|
||||
pdev->name))
|
||||
return -EBUSY;
|
||||
#endif
|
||||
priv->baseaddr = res->start;
|
||||
priv->reg = ioremap(priv->baseaddr, priv->size);
|
||||
if (!priv->reg) {
|
||||
ret = -ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
priv->reg = devm_ioremap(&pdev->dev, priv->baseaddr, priv->size);
|
||||
if (!priv->reg)
|
||||
return -ENOMEM;
|
||||
|
||||
spin_lock_init(&priv->lock);
|
||||
|
||||
platform_set_drvdata(pdev, priv);
|
||||
|
||||
priv->rtc = rtc_device_register("m48t35", &pdev->dev,
|
||||
priv->rtc = devm_rtc_device_register(&pdev->dev, "m48t35",
|
||||
&m48t35_ops, THIS_MODULE);
|
||||
if (IS_ERR(priv->rtc)) {
|
||||
ret = PTR_ERR(priv->rtc);
|
||||
goto out;
|
||||
}
|
||||
if (IS_ERR(priv->rtc))
|
||||
return PTR_ERR(priv->rtc);
|
||||
|
||||
return 0;
|
||||
|
||||
out:
|
||||
if (priv->reg)
|
||||
iounmap(priv->reg);
|
||||
if (priv->baseaddr)
|
||||
release_mem_region(priv->baseaddr, priv->size);
|
||||
kfree(priv);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int m48t35_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct m48t35_priv *priv = platform_get_drvdata(pdev);
|
||||
|
||||
rtc_device_unregister(priv->rtc);
|
||||
iounmap(priv->reg);
|
||||
#ifndef CONFIG_SGI_IP27
|
||||
release_mem_region(priv->baseaddr, priv->size);
|
||||
#endif
|
||||
kfree(priv);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -148,8 +148,10 @@ static int m48t86_rtc_probe(struct platform_device *dev)
|
|||
{
|
||||
unsigned char reg;
|
||||
struct m48t86_ops *ops = dev->dev.platform_data;
|
||||
struct rtc_device *rtc = rtc_device_register("m48t86",
|
||||
&dev->dev, &m48t86_rtc_ops, THIS_MODULE);
|
||||
struct rtc_device *rtc;
|
||||
|
||||
rtc = devm_rtc_device_register(&dev->dev, "m48t86",
|
||||
&m48t86_rtc_ops, THIS_MODULE);
|
||||
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
|
@ -166,11 +168,6 @@ static int m48t86_rtc_probe(struct platform_device *dev)
|
|||
|
||||
static int m48t86_rtc_remove(struct platform_device *dev)
|
||||
{
|
||||
struct rtc_device *rtc = platform_get_drvdata(dev);
|
||||
|
||||
if (rtc)
|
||||
rtc_device_unregister(rtc);
|
||||
|
||||
platform_set_drvdata(dev, NULL);
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -214,11 +214,6 @@ static int max6900_rtc_set_time(struct device *dev, struct rtc_time *tm)
|
|||
|
||||
static int max6900_remove(struct i2c_client *client)
|
||||
{
|
||||
struct rtc_device *rtc = i2c_get_clientdata(client);
|
||||
|
||||
if (rtc)
|
||||
rtc_device_unregister(rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -237,8 +232,8 @@ max6900_probe(struct i2c_client *client, const struct i2c_device_id *id)
|
|||
|
||||
dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
|
||||
|
||||
rtc = rtc_device_register(max6900_driver.driver.name,
|
||||
&client->dev, &max6900_rtc_ops, THIS_MODULE);
|
||||
rtc = devm_rtc_device_register(&client->dev, max6900_driver.driver.name,
|
||||
&max6900_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
|
||||
|
|
|
@ -93,24 +93,24 @@ static int max6902_set_time(struct device *dev, struct rtc_time *dt)
|
|||
dt->tm_year = dt->tm_year + 1900;
|
||||
|
||||
/* Remove write protection */
|
||||
max6902_set_reg(dev, 0xF, 0);
|
||||
max6902_set_reg(dev, MAX6902_REG_CONTROL, 0);
|
||||
|
||||
max6902_set_reg(dev, 0x01, bin2bcd(dt->tm_sec));
|
||||
max6902_set_reg(dev, 0x03, bin2bcd(dt->tm_min));
|
||||
max6902_set_reg(dev, 0x05, bin2bcd(dt->tm_hour));
|
||||
max6902_set_reg(dev, MAX6902_REG_SECONDS, bin2bcd(dt->tm_sec));
|
||||
max6902_set_reg(dev, MAX6902_REG_MINUTES, bin2bcd(dt->tm_min));
|
||||
max6902_set_reg(dev, MAX6902_REG_HOURS, bin2bcd(dt->tm_hour));
|
||||
|
||||
max6902_set_reg(dev, 0x07, bin2bcd(dt->tm_mday));
|
||||
max6902_set_reg(dev, 0x09, bin2bcd(dt->tm_mon + 1));
|
||||
max6902_set_reg(dev, 0x0B, bin2bcd(dt->tm_wday));
|
||||
max6902_set_reg(dev, 0x0D, bin2bcd(dt->tm_year % 100));
|
||||
max6902_set_reg(dev, 0x13, bin2bcd(dt->tm_year / 100));
|
||||
max6902_set_reg(dev, MAX6902_REG_DATE, bin2bcd(dt->tm_mday));
|
||||
max6902_set_reg(dev, MAX6902_REG_MONTH, bin2bcd(dt->tm_mon + 1));
|
||||
max6902_set_reg(dev, MAX6902_REG_DAY, bin2bcd(dt->tm_wday));
|
||||
max6902_set_reg(dev, MAX6902_REG_YEAR, bin2bcd(dt->tm_year % 100));
|
||||
max6902_set_reg(dev, MAX6902_REG_CENTURY, bin2bcd(dt->tm_year / 100));
|
||||
|
||||
/* Compulab used a delay here. However, the datasheet
|
||||
* does not mention a delay being required anywhere... */
|
||||
/* delay(2000); */
|
||||
|
||||
/* Write protect */
|
||||
max6902_set_reg(dev, 0xF, 0x80);
|
||||
max6902_set_reg(dev, MAX6902_REG_CONTROL, 0x80);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -134,20 +134,17 @@ static int max6902_probe(struct spi_device *spi)
|
|||
if (res != 0)
|
||||
return res;
|
||||
|
||||
rtc = rtc_device_register("max6902",
|
||||
&spi->dev, &max6902_rtc_ops, THIS_MODULE);
|
||||
rtc = devm_rtc_device_register(&spi->dev, "max6902",
|
||||
&max6902_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc))
|
||||
return PTR_ERR(rtc);
|
||||
|
||||
dev_set_drvdata(&spi->dev, rtc);
|
||||
spi_set_drvdata(spi, rtc);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int max6902_remove(struct spi_device *spi)
|
||||
{
|
||||
struct rtc_device *rtc = dev_get_drvdata(&spi->dev);
|
||||
|
||||
rtc_device_unregister(rtc);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -24,7 +24,7 @@
|
|||
|
||||
/* RTC Control Register */
|
||||
#define BCD_EN_SHIFT 0
|
||||
#define BCD_EN_MASK (1 << BCD_EN_SHIFT)
|
||||
#define BCD_EN_MASK (1 << BCD_EN_SHIFT)
|
||||
#define MODEL24_SHIFT 1
|
||||
#define MODEL24_MASK (1 << MODEL24_SHIFT)
|
||||
/* RTC Update Register1 */
|
||||
|
@ -33,12 +33,12 @@
|
|||
#define RTC_RBUDR_SHIFT 4
|
||||
#define RTC_RBUDR_MASK (1 << RTC_RBUDR_SHIFT)
|
||||
/* WTSR and SMPL Register */
|
||||
#define WTSRT_SHIFT 0
|
||||
#define SMPLT_SHIFT 2
|
||||
#define WTSRT_SHIFT 0
|
||||
#define SMPLT_SHIFT 2
|
||||
#define WTSR_EN_SHIFT 6
|
||||
#define SMPL_EN_SHIFT 7
|
||||
#define WTSRT_MASK (3 << WTSRT_SHIFT)
|
||||
#define SMPLT_MASK (3 << SMPLT_SHIFT)
|
||||
#define WTSRT_MASK (3 << WTSRT_SHIFT)
|
||||
#define SMPLT_MASK (3 << SMPLT_SHIFT)
|
||||
#define WTSR_EN_MASK (1 << WTSR_EN_SHIFT)
|
||||
#define SMPL_EN_MASK (1 << SMPL_EN_SHIFT)
|
||||
/* RTC Hour register */
|
||||
|
@ -466,7 +466,7 @@ static void max77686_rtc_enable_smpl(struct max77686_rtc_info *info, bool enable
|
|||
|
||||
val = 0;
|
||||
regmap_read(info->max77686->rtc_regmap, MAX77686_WTSR_SMPL_CNTL, &val);
|
||||
pr_info("%s: WTSR_SMPL(0x%02x)\n", __func__, val);
|
||||
dev_info(info->dev, "%s: WTSR_SMPL(0x%02x)\n", __func__, val);
|
||||
}
|
||||
#endif /* MAX77686_RTC_WTSR_SMPL */
|
||||
|
||||
|
@ -505,7 +505,8 @@ static int max77686_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
dev_info(&pdev->dev, "%s\n", __func__);
|
||||
|
||||
info = kzalloc(sizeof(struct max77686_rtc_info), GFP_KERNEL);
|
||||
info = devm_kzalloc(&pdev->dev, sizeof(struct max77686_rtc_info),
|
||||
GFP_KERNEL);
|
||||
if (!info)
|
||||
return -ENOMEM;
|
||||
|
||||
|
@ -513,13 +514,12 @@ static int max77686_rtc_probe(struct platform_device *pdev)
|
|||
info->dev = &pdev->dev;
|
||||
info->max77686 = max77686;
|
||||
info->rtc = max77686->rtc;
|
||||
info->max77686->rtc_regmap = regmap_init_i2c(info->max77686->rtc,
|
||||
info->max77686->rtc_regmap = devm_regmap_init_i2c(info->max77686->rtc,
|
||||
&max77686_rtc_regmap_config);
|
||||
if (IS_ERR(info->max77686->rtc_regmap)) {
|
||||
ret = PTR_ERR(info->max77686->rtc_regmap);
|
||||
dev_err(info->max77686->dev, "Failed to allocate register map: %d\n",
|
||||
ret);
|
||||
kfree(info);
|
||||
return ret;
|
||||
}
|
||||
platform_set_drvdata(pdev, info);
|
||||
|
@ -538,8 +538,8 @@ static int max77686_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
device_init_wakeup(&pdev->dev, 1);
|
||||
|
||||
info->rtc_dev = rtc_device_register("max77686-rtc", &pdev->dev,
|
||||
&max77686_rtc_ops, THIS_MODULE);
|
||||
info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max77686-rtc",
|
||||
&max77686_rtc_ops, THIS_MODULE);
|
||||
|
||||
if (IS_ERR(info->rtc_dev)) {
|
||||
dev_info(&pdev->dev, "%s: fail\n", __func__);
|
||||
|
@ -551,36 +551,24 @@ static int max77686_rtc_probe(struct platform_device *pdev)
|
|||
goto err_rtc;
|
||||
}
|
||||
virq = irq_create_mapping(max77686->irq_domain, MAX77686_RTCIRQ_RTCA1);
|
||||
if (!virq)
|
||||
goto err_rtc;
|
||||
info->virq = virq;
|
||||
|
||||
ret = request_threaded_irq(virq, NULL, max77686_rtc_alarm_irq, 0,
|
||||
"rtc-alarm0", info);
|
||||
if (ret < 0) {
|
||||
dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
|
||||
info->virq, ret);
|
||||
if (!virq) {
|
||||
ret = -ENXIO;
|
||||
goto err_rtc;
|
||||
}
|
||||
info->virq = virq;
|
||||
|
||||
ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,
|
||||
max77686_rtc_alarm_irq, 0, "rtc-alarm0", info);
|
||||
if (ret < 0)
|
||||
dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
|
||||
info->virq, ret);
|
||||
|
||||
goto out;
|
||||
err_rtc:
|
||||
kfree(info);
|
||||
return ret;
|
||||
out:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int max77686_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct max77686_rtc_info *info = platform_get_drvdata(pdev);
|
||||
|
||||
if (info) {
|
||||
free_irq(info->virq, info);
|
||||
rtc_device_unregister(info->rtc_dev);
|
||||
kfree(info);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -594,11 +582,14 @@ static void max77686_rtc_shutdown(struct platform_device *pdev)
|
|||
for (i = 0; i < 3; i++) {
|
||||
max77686_rtc_enable_wtsr(info, false);
|
||||
regmap_read(info->max77686->rtc_regmap, MAX77686_WTSR_SMPL_CNTL, &val);
|
||||
pr_info("%s: WTSR_SMPL reg(0x%02x)\n", __func__, val);
|
||||
if (val & WTSR_EN_MASK)
|
||||
pr_emerg("%s: fail to disable WTSR\n", __func__);
|
||||
else {
|
||||
pr_info("%s: success to disable WTSR\n", __func__);
|
||||
dev_info(info->dev, "%s: WTSR_SMPL reg(0x%02x)\n", __func__,
|
||||
val);
|
||||
if (val & WTSR_EN_MASK) {
|
||||
dev_emerg(info->dev, "%s: fail to disable WTSR\n",
|
||||
__func__);
|
||||
} else {
|
||||
dev_info(info->dev, "%s: success to disable WTSR\n",
|
||||
__func__);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -624,18 +615,8 @@ static struct platform_driver max77686_rtc_driver = {
|
|||
.id_table = rtc_id,
|
||||
};
|
||||
|
||||
static int __init max77686_rtc_init(void)
|
||||
{
|
||||
return platform_driver_register(&max77686_rtc_driver);
|
||||
}
|
||||
module_init(max77686_rtc_init);
|
||||
|
||||
static void __exit max77686_rtc_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&max77686_rtc_driver);
|
||||
}
|
||||
module_exit(max77686_rtc_exit);
|
||||
module_platform_driver(max77686_rtc_driver);
|
||||
|
||||
MODULE_DESCRIPTION("Maxim MAX77686 RTC driver");
|
||||
MODULE_AUTHOR("<woong.byun@samsung.com>");
|
||||
MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
|
|
@ -190,7 +190,7 @@ static int max8907_rtc_probe(struct platform_device *pdev)
|
|||
rtc->max8907 = max8907;
|
||||
rtc->regmap = max8907->regmap_rtc;
|
||||
|
||||
rtc->rtc_dev = rtc_device_register("max8907-rtc", &pdev->dev,
|
||||
rtc->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8907-rtc",
|
||||
&max8907_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc->rtc_dev)) {
|
||||
ret = PTR_ERR(rtc->rtc_dev);
|
||||
|
@ -200,33 +200,21 @@ static int max8907_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
rtc->irq = regmap_irq_get_virq(max8907->irqc_rtc,
|
||||
MAX8907_IRQ_RTC_ALARM0);
|
||||
if (rtc->irq < 0) {
|
||||
ret = rtc->irq;
|
||||
goto err_unregister;
|
||||
}
|
||||
if (rtc->irq < 0)
|
||||
return rtc->irq;
|
||||
|
||||
ret = devm_request_threaded_irq(&pdev->dev, rtc->irq, NULL,
|
||||
max8907_irq_handler,
|
||||
IRQF_ONESHOT, "max8907-alarm0", rtc);
|
||||
if (ret < 0) {
|
||||
if (ret < 0)
|
||||
dev_err(&pdev->dev, "Failed to request IRQ%d: %d\n",
|
||||
rtc->irq, ret);
|
||||
goto err_unregister;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err_unregister:
|
||||
rtc_device_unregister(rtc->rtc_dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int max8907_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct max8907_rtc *rtc = platform_get_drvdata(pdev);
|
||||
|
||||
rtc_device_unregister(rtc->rtc_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -253,7 +253,8 @@ static int max8925_rtc_probe(struct platform_device *pdev)
|
|||
struct max8925_rtc_info *info;
|
||||
int ret;
|
||||
|
||||
info = kzalloc(sizeof(struct max8925_rtc_info), GFP_KERNEL);
|
||||
info = devm_kzalloc(&pdev->dev, sizeof(struct max8925_rtc_info),
|
||||
GFP_KERNEL);
|
||||
if (!info)
|
||||
return -ENOMEM;
|
||||
info->chip = chip;
|
||||
|
@ -261,12 +262,13 @@ static int max8925_rtc_probe(struct platform_device *pdev)
|
|||
info->dev = &pdev->dev;
|
||||
info->irq = platform_get_irq(pdev, 0);
|
||||
|
||||
ret = request_threaded_irq(info->irq, NULL, rtc_update_handler,
|
||||
IRQF_ONESHOT, "rtc-alarm0", info);
|
||||
ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
|
||||
rtc_update_handler, IRQF_ONESHOT,
|
||||
"rtc-alarm0", info);
|
||||
if (ret < 0) {
|
||||
dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
|
||||
info->irq, ret);
|
||||
goto out_irq;
|
||||
goto err;
|
||||
}
|
||||
|
||||
dev_set_drvdata(&pdev->dev, info);
|
||||
|
@ -275,32 +277,22 @@ static int max8925_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
device_init_wakeup(&pdev->dev, 1);
|
||||
|
||||
info->rtc_dev = rtc_device_register("max8925-rtc", &pdev->dev,
|
||||
info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8925-rtc",
|
||||
&max8925_rtc_ops, THIS_MODULE);
|
||||
ret = PTR_ERR(info->rtc_dev);
|
||||
if (IS_ERR(info->rtc_dev)) {
|
||||
dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
|
||||
goto out_rtc;
|
||||
goto err;
|
||||
}
|
||||
|
||||
return 0;
|
||||
out_rtc:
|
||||
err:
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
free_irq(info->irq, info);
|
||||
out_irq:
|
||||
kfree(info);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int max8925_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct max8925_rtc_info *info = platform_get_drvdata(pdev);
|
||||
|
||||
if (info) {
|
||||
free_irq(info->irq, info);
|
||||
rtc_device_unregister(info->rtc_dev);
|
||||
kfree(info);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -479,8 +479,8 @@ static int max8997_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
device_init_wakeup(&pdev->dev, 1);
|
||||
|
||||
info->rtc_dev = rtc_device_register("max8997-rtc", &pdev->dev,
|
||||
&max8997_rtc_ops, THIS_MODULE);
|
||||
info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8997-rtc",
|
||||
&max8997_rtc_ops, THIS_MODULE);
|
||||
|
||||
if (IS_ERR(info->rtc_dev)) {
|
||||
ret = PTR_ERR(info->rtc_dev);
|
||||
|
@ -491,6 +491,7 @@ static int max8997_rtc_probe(struct platform_device *pdev)
|
|||
virq = irq_create_mapping(max8997->irq_domain, MAX8997_PMICIRQ_RTCA1);
|
||||
if (!virq) {
|
||||
dev_err(&pdev->dev, "Failed to create mapping alarm IRQ\n");
|
||||
ret = -ENXIO;
|
||||
goto err_out;
|
||||
}
|
||||
info->virq = virq;
|
||||
|
@ -498,26 +499,16 @@ static int max8997_rtc_probe(struct platform_device *pdev)
|
|||
ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,
|
||||
max8997_rtc_alarm_irq, 0,
|
||||
"rtc-alarm0", info);
|
||||
if (ret < 0) {
|
||||
if (ret < 0)
|
||||
dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
|
||||
info->virq, ret);
|
||||
goto err_out;
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
||||
err_out:
|
||||
rtc_device_unregister(info->rtc_dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int max8997_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct max8997_rtc_info *info = platform_get_drvdata(pdev);
|
||||
|
||||
if (info)
|
||||
rtc_device_unregister(info->rtc_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -256,7 +256,8 @@ static int max8998_rtc_probe(struct platform_device *pdev)
|
|||
struct max8998_rtc_info *info;
|
||||
int ret;
|
||||
|
||||
info = kzalloc(sizeof(struct max8998_rtc_info), GFP_KERNEL);
|
||||
info = devm_kzalloc(&pdev->dev, sizeof(struct max8998_rtc_info),
|
||||
GFP_KERNEL);
|
||||
if (!info)
|
||||
return -ENOMEM;
|
||||
|
||||
|
@ -267,7 +268,7 @@ static int max8998_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
platform_set_drvdata(pdev, info);
|
||||
|
||||
info->rtc_dev = rtc_device_register("max8998-rtc", &pdev->dev,
|
||||
info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8998-rtc",
|
||||
&max8998_rtc_ops, THIS_MODULE);
|
||||
|
||||
if (IS_ERR(info->rtc_dev)) {
|
||||
|
@ -276,8 +277,8 @@ static int max8998_rtc_probe(struct platform_device *pdev)
|
|||
goto out_rtc;
|
||||
}
|
||||
|
||||
ret = request_threaded_irq(info->irq, NULL, max8998_rtc_alarm_irq, 0,
|
||||
"rtc-alarm0", info);
|
||||
ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
|
||||
max8998_rtc_alarm_irq, 0, "rtc-alarm0", info);
|
||||
|
||||
if (ret < 0)
|
||||
dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
|
||||
|
@ -294,20 +295,11 @@ static int max8998_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
out_rtc:
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
kfree(info);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int max8998_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct max8998_rtc_info *info = platform_get_drvdata(pdev);
|
||||
|
||||
if (info) {
|
||||
free_irq(info->irq, info);
|
||||
rtc_device_unregister(info->rtc_dev);
|
||||
kfree(info);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -316,7 +316,7 @@ static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
|
|||
struct mc13xxx *mc13xxx;
|
||||
int rtcrst_pending;
|
||||
|
||||
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
|
||||
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
|
||||
if (!priv)
|
||||
return -ENOMEM;
|
||||
|
||||
|
@ -351,8 +351,8 @@ static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
mc13xxx_unlock(mc13xxx);
|
||||
|
||||
priv->rtc = rtc_device_register(pdev->name,
|
||||
&pdev->dev, &mc13xxx_rtc_ops, THIS_MODULE);
|
||||
priv->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&mc13xxx_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(priv->rtc)) {
|
||||
ret = PTR_ERR(priv->rtc);
|
||||
|
||||
|
@ -372,7 +372,6 @@ err_reset_irq_request:
|
|||
mc13xxx_unlock(mc13xxx);
|
||||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
kfree(priv);
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
@ -384,8 +383,6 @@ static int __exit mc13xxx_rtc_remove(struct platform_device *pdev)
|
|||
|
||||
mc13xxx_lock(priv->mc13xxx);
|
||||
|
||||
rtc_device_unregister(priv->rtc);
|
||||
|
||||
mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TODA, priv);
|
||||
mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_1HZ, priv);
|
||||
mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_RTCRST, priv);
|
||||
|
@ -394,8 +391,6 @@ static int __exit mc13xxx_rtc_remove(struct platform_device *pdev)
|
|||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
kfree(priv);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -420,17 +415,7 @@ static struct platform_driver mc13xxx_rtc_driver = {
|
|||
},
|
||||
};
|
||||
|
||||
static int __init mc13xxx_rtc_init(void)
|
||||
{
|
||||
return platform_driver_probe(&mc13xxx_rtc_driver, &mc13xxx_rtc_probe);
|
||||
}
|
||||
module_init(mc13xxx_rtc_init);
|
||||
|
||||
static void __exit mc13xxx_rtc_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&mc13xxx_rtc_driver);
|
||||
}
|
||||
module_exit(mc13xxx_rtc_exit);
|
||||
module_platform_driver_probe(mc13xxx_rtc_driver, &mc13xxx_rtc_probe);
|
||||
|
||||
MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
|
||||
MODULE_DESCRIPTION("RTC driver for Freescale MC13XXX PMIC");
|
||||
|
|
|
@ -194,30 +194,28 @@ static const struct rtc_class_ops msm6242_rtc_ops = {
|
|||
.set_time = msm6242_set_time,
|
||||
};
|
||||
|
||||
static int __init msm6242_rtc_probe(struct platform_device *dev)
|
||||
static int __init msm6242_rtc_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct resource *res;
|
||||
struct msm6242_priv *priv;
|
||||
struct rtc_device *rtc;
|
||||
int error;
|
||||
|
||||
res = platform_get_resource(dev, IORESOURCE_MEM, 0);
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
if (!res)
|
||||
return -ENODEV;
|
||||
|
||||
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
|
||||
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
|
||||
if (!priv)
|
||||
return -ENOMEM;
|
||||
|
||||
priv->regs = ioremap(res->start, resource_size(res));
|
||||
if (!priv->regs) {
|
||||
error = -ENOMEM;
|
||||
goto out_free_priv;
|
||||
}
|
||||
platform_set_drvdata(dev, priv);
|
||||
priv->regs = devm_ioremap(&pdev->dev, res->start, resource_size(res));
|
||||
if (!priv->regs)
|
||||
return -ENOMEM;
|
||||
platform_set_drvdata(pdev, priv);
|
||||
|
||||
rtc = rtc_device_register("rtc-msm6242", &dev->dev, &msm6242_rtc_ops,
|
||||
THIS_MODULE);
|
||||
rtc = devm_rtc_device_register(&pdev->dev, "rtc-msm6242",
|
||||
&msm6242_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc)) {
|
||||
error = PTR_ERR(rtc);
|
||||
goto out_unmap;
|
||||
|
@ -227,20 +225,12 @@ static int __init msm6242_rtc_probe(struct platform_device *dev)
|
|||
return 0;
|
||||
|
||||
out_unmap:
|
||||
platform_set_drvdata(dev, NULL);
|
||||
iounmap(priv->regs);
|
||||
out_free_priv:
|
||||
kfree(priv);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
return error;
|
||||
}
|
||||
|
||||
static int __exit msm6242_rtc_remove(struct platform_device *dev)
|
||||
static int __exit msm6242_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct msm6242_priv *priv = platform_get_drvdata(dev);
|
||||
|
||||
rtc_device_unregister(priv->rtc);
|
||||
iounmap(priv->regs);
|
||||
kfree(priv);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -252,18 +242,7 @@ static struct platform_driver msm6242_rtc_driver = {
|
|||
.remove = __exit_p(msm6242_rtc_remove),
|
||||
};
|
||||
|
||||
static int __init msm6242_rtc_init(void)
|
||||
{
|
||||
return platform_driver_probe(&msm6242_rtc_driver, msm6242_rtc_probe);
|
||||
}
|
||||
|
||||
static void __exit msm6242_rtc_fini(void)
|
||||
{
|
||||
platform_driver_unregister(&msm6242_rtc_driver);
|
||||
}
|
||||
|
||||
module_init(msm6242_rtc_init);
|
||||
module_exit(msm6242_rtc_fini);
|
||||
module_platform_driver_probe(msm6242_rtc_driver, msm6242_rtc_probe);
|
||||
|
||||
MODULE_AUTHOR("Geert Uytterhoeven <geert@linux-m68k.org>");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
|
|
@ -217,7 +217,7 @@ static const struct rtc_class_ops mv_rtc_alarm_ops = {
|
|||
.alarm_irq_enable = mv_rtc_alarm_irq_enable,
|
||||
};
|
||||
|
||||
static int mv_rtc_probe(struct platform_device *pdev)
|
||||
static int __init mv_rtc_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct resource *res;
|
||||
struct rtc_plat_data *pdata;
|
||||
|
@ -272,12 +272,13 @@ static int mv_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
if (pdata->irq >= 0) {
|
||||
device_init_wakeup(&pdev->dev, 1);
|
||||
pdata->rtc = rtc_device_register(pdev->name, &pdev->dev,
|
||||
pdata->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&mv_rtc_alarm_ops,
|
||||
THIS_MODULE);
|
||||
} else
|
||||
pdata->rtc = rtc_device_register(pdev->name, &pdev->dev,
|
||||
} else {
|
||||
pdata->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&mv_rtc_ops, THIS_MODULE);
|
||||
}
|
||||
if (IS_ERR(pdata->rtc)) {
|
||||
ret = PTR_ERR(pdata->rtc);
|
||||
goto out;
|
||||
|
@ -308,7 +309,6 @@ static int __exit mv_rtc_remove(struct platform_device *pdev)
|
|||
if (pdata->irq >= 0)
|
||||
device_init_wakeup(&pdev->dev, 0);
|
||||
|
||||
rtc_device_unregister(pdata->rtc);
|
||||
if (!IS_ERR(pdata->clk))
|
||||
clk_disable_unprepare(pdata->clk);
|
||||
|
||||
|
@ -331,18 +331,7 @@ static struct platform_driver mv_rtc_driver = {
|
|||
},
|
||||
};
|
||||
|
||||
static __init int mv_init(void)
|
||||
{
|
||||
return platform_driver_probe(&mv_rtc_driver, mv_rtc_probe);
|
||||
}
|
||||
|
||||
static __exit void mv_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&mv_rtc_driver);
|
||||
}
|
||||
|
||||
module_init(mv_init);
|
||||
module_exit(mv_exit);
|
||||
module_platform_driver_probe(mv_rtc_driver, mv_rtc_probe);
|
||||
|
||||
MODULE_AUTHOR("Saeed Bishara <saeed@marvell.com>");
|
||||
MODULE_DESCRIPTION("Marvell RTC driver");
|
||||
|
|
|
@ -439,7 +439,7 @@ static int mxc_rtc_probe(struct platform_device *pdev)
|
|||
if (pdata->irq >=0)
|
||||
device_init_wakeup(&pdev->dev, 1);
|
||||
|
||||
rtc = rtc_device_register(pdev->name, &pdev->dev, &mxc_rtc_ops,
|
||||
rtc = devm_rtc_device_register(&pdev->dev, pdev->name, &mxc_rtc_ops,
|
||||
THIS_MODULE);
|
||||
if (IS_ERR(rtc)) {
|
||||
ret = PTR_ERR(rtc);
|
||||
|
@ -464,15 +464,13 @@ static int mxc_rtc_remove(struct platform_device *pdev)
|
|||
{
|
||||
struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
|
||||
|
||||
rtc_device_unregister(pdata->rtc);
|
||||
|
||||
clk_disable_unprepare(pdata->clk);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
static int mxc_rtc_suspend(struct device *dev)
|
||||
{
|
||||
struct rtc_plat_data *pdata = dev_get_drvdata(dev);
|
||||
|
@ -492,19 +490,14 @@ static int mxc_rtc_resume(struct device *dev)
|
|||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct dev_pm_ops mxc_rtc_pm_ops = {
|
||||
.suspend = mxc_rtc_suspend,
|
||||
.resume = mxc_rtc_resume,
|
||||
};
|
||||
#endif
|
||||
|
||||
static SIMPLE_DEV_PM_OPS(mxc_rtc_pm_ops, mxc_rtc_suspend, mxc_rtc_resume);
|
||||
|
||||
static struct platform_driver mxc_rtc_driver = {
|
||||
.driver = {
|
||||
.name = "mxc_rtc",
|
||||
#ifdef CONFIG_PM
|
||||
.pm = &mxc_rtc_pm_ops,
|
||||
#endif
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
.id_table = imx_rtc_devtype,
|
||||
|
|
|
@ -222,13 +222,13 @@ static struct rtc_class_ops nuc900_rtc_ops = {
|
|||
.alarm_irq_enable = nuc900_alarm_irq_enable,
|
||||
};
|
||||
|
||||
static int nuc900_rtc_probe(struct platform_device *pdev)
|
||||
static int __init nuc900_rtc_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct resource *res;
|
||||
struct nuc900_rtc *nuc900_rtc;
|
||||
int err = 0;
|
||||
|
||||
nuc900_rtc = kzalloc(sizeof(struct nuc900_rtc), GFP_KERNEL);
|
||||
nuc900_rtc = devm_kzalloc(&pdev->dev, sizeof(struct nuc900_rtc),
|
||||
GFP_KERNEL);
|
||||
if (!nuc900_rtc) {
|
||||
dev_err(&pdev->dev, "kzalloc nuc900_rtc failed\n");
|
||||
return -ENOMEM;
|
||||
|
@ -236,93 +236,51 @@ static int nuc900_rtc_probe(struct platform_device *pdev)
|
|||
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
if (!res) {
|
||||
dev_err(&pdev->dev, "platform_get_resource failed\n");
|
||||
err = -ENXIO;
|
||||
goto fail1;
|
||||
return -ENXIO;
|
||||
}
|
||||
|
||||
if (!request_mem_region(res->start, resource_size(res),
|
||||
pdev->name)) {
|
||||
dev_err(&pdev->dev, "request_mem_region failed\n");
|
||||
err = -EBUSY;
|
||||
goto fail1;
|
||||
}
|
||||
|
||||
nuc900_rtc->rtc_reg = ioremap(res->start, resource_size(res));
|
||||
if (!nuc900_rtc->rtc_reg) {
|
||||
dev_err(&pdev->dev, "ioremap rtc_reg failed\n");
|
||||
err = -ENOMEM;
|
||||
goto fail2;
|
||||
}
|
||||
nuc900_rtc->rtc_reg = devm_ioremap_resource(&pdev->dev, res);
|
||||
if (IS_ERR(nuc900_rtc->rtc_reg))
|
||||
return PTR_ERR(nuc900_rtc->rtc_reg);
|
||||
|
||||
platform_set_drvdata(pdev, nuc900_rtc);
|
||||
|
||||
nuc900_rtc->rtcdev = rtc_device_register(pdev->name, &pdev->dev,
|
||||
nuc900_rtc->rtcdev = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&nuc900_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(nuc900_rtc->rtcdev)) {
|
||||
dev_err(&pdev->dev, "rtc device register failed\n");
|
||||
err = PTR_ERR(nuc900_rtc->rtcdev);
|
||||
goto fail3;
|
||||
return PTR_ERR(nuc900_rtc->rtcdev);
|
||||
}
|
||||
|
||||
__raw_writel(__raw_readl(nuc900_rtc->rtc_reg + REG_RTC_TSSR) | MODE24,
|
||||
nuc900_rtc->rtc_reg + REG_RTC_TSSR);
|
||||
|
||||
nuc900_rtc->irq_num = platform_get_irq(pdev, 0);
|
||||
if (request_irq(nuc900_rtc->irq_num, nuc900_rtc_interrupt,
|
||||
0, "nuc900rtc", nuc900_rtc)) {
|
||||
if (devm_request_irq(&pdev->dev, nuc900_rtc->irq_num,
|
||||
nuc900_rtc_interrupt, 0, "nuc900rtc", nuc900_rtc)) {
|
||||
dev_err(&pdev->dev, "NUC900 RTC request irq failed\n");
|
||||
err = -EBUSY;
|
||||
goto fail4;
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
fail4: rtc_device_unregister(nuc900_rtc->rtcdev);
|
||||
fail3: iounmap(nuc900_rtc->rtc_reg);
|
||||
fail2: release_mem_region(res->start, resource_size(res));
|
||||
fail1: kfree(nuc900_rtc);
|
||||
return err;
|
||||
}
|
||||
|
||||
static int nuc900_rtc_remove(struct platform_device *pdev)
|
||||
static int __exit nuc900_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct nuc900_rtc *nuc900_rtc = platform_get_drvdata(pdev);
|
||||
struct resource *res;
|
||||
|
||||
free_irq(nuc900_rtc->irq_num, nuc900_rtc);
|
||||
rtc_device_unregister(nuc900_rtc->rtcdev);
|
||||
iounmap(nuc900_rtc->rtc_reg);
|
||||
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
release_mem_region(res->start, resource_size(res));
|
||||
|
||||
kfree(nuc900_rtc);
|
||||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver nuc900_rtc_driver = {
|
||||
.remove = nuc900_rtc_remove,
|
||||
.remove = __exit_p(nuc900_rtc_remove),
|
||||
.driver = {
|
||||
.name = "nuc900-rtc",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init nuc900_rtc_init(void)
|
||||
{
|
||||
return platform_driver_probe(&nuc900_rtc_driver, nuc900_rtc_probe);
|
||||
}
|
||||
|
||||
static void __exit nuc900_rtc_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&nuc900_rtc_driver);
|
||||
}
|
||||
|
||||
module_init(nuc900_rtc_init);
|
||||
module_exit(nuc900_rtc_exit);
|
||||
module_platform_driver_probe(nuc900_rtc_driver, nuc900_rtc_probe);
|
||||
|
||||
MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
|
||||
MODULE_DESCRIPTION("nuc910/nuc920 RTC driver");
|
||||
|
|
|
@ -324,7 +324,7 @@ MODULE_DEVICE_TABLE(of, omap_rtc_of_match);
|
|||
|
||||
static int __init omap_rtc_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct resource *res, *mem;
|
||||
struct resource *res;
|
||||
struct rtc_device *rtc;
|
||||
u8 reg, new_ctrl;
|
||||
const struct platform_device_id *id_entry;
|
||||
|
@ -352,18 +352,9 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
|
|||
return -ENOENT;
|
||||
}
|
||||
|
||||
mem = request_mem_region(res->start, resource_size(res), pdev->name);
|
||||
if (!mem) {
|
||||
pr_debug("%s: RTC registers at %08x are not free\n",
|
||||
pdev->name, res->start);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
rtc_base = ioremap(res->start, resource_size(res));
|
||||
if (!rtc_base) {
|
||||
pr_debug("%s: RTC registers can't be mapped\n", pdev->name);
|
||||
goto fail;
|
||||
}
|
||||
rtc_base = devm_ioremap_resource(&pdev->dev, res);
|
||||
if (IS_ERR(rtc_base))
|
||||
return PTR_ERR(rtc_base);
|
||||
|
||||
/* Enable the clock/module so that we can access the registers */
|
||||
pm_runtime_enable(&pdev->dev);
|
||||
|
@ -375,7 +366,7 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
|
|||
rtc_writel(KICK1_VALUE, OMAP_RTC_KICK1_REG);
|
||||
}
|
||||
|
||||
rtc = rtc_device_register(pdev->name, &pdev->dev,
|
||||
rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&omap_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(rtc)) {
|
||||
pr_debug("%s: can't register RTC device, err %ld\n",
|
||||
|
@ -383,7 +374,6 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
|
|||
goto fail0;
|
||||
}
|
||||
platform_set_drvdata(pdev, rtc);
|
||||
dev_set_drvdata(&rtc->dev, mem);
|
||||
|
||||
/* clear pending irqs, and set 1/second periodic,
|
||||
* which we'll use instead of update irqs
|
||||
|
@ -401,18 +391,18 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
|
|||
rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
|
||||
|
||||
/* handle periodic and alarm irqs */
|
||||
if (request_irq(omap_rtc_timer, rtc_irq, 0,
|
||||
if (devm_request_irq(&pdev->dev, omap_rtc_timer, rtc_irq, 0,
|
||||
dev_name(&rtc->dev), rtc)) {
|
||||
pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
|
||||
pdev->name, omap_rtc_timer);
|
||||
goto fail1;
|
||||
goto fail0;
|
||||
}
|
||||
if ((omap_rtc_timer != omap_rtc_alarm) &&
|
||||
(request_irq(omap_rtc_alarm, rtc_irq, 0,
|
||||
(devm_request_irq(&pdev->dev, omap_rtc_alarm, rtc_irq, 0,
|
||||
dev_name(&rtc->dev), rtc))) {
|
||||
pr_debug("%s: RTC alarm interrupt IRQ%d already claimed\n",
|
||||
pdev->name, omap_rtc_alarm);
|
||||
goto fail2;
|
||||
goto fail0;
|
||||
}
|
||||
|
||||
/* On boards with split power, RTC_ON_NOFF won't reset the RTC */
|
||||
|
@ -446,25 +436,16 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
return 0;
|
||||
|
||||
fail2:
|
||||
free_irq(omap_rtc_timer, rtc);
|
||||
fail1:
|
||||
rtc_device_unregister(rtc);
|
||||
fail0:
|
||||
if (id_entry && (id_entry->driver_data & OMAP_RTC_HAS_KICKER))
|
||||
rtc_writel(0, OMAP_RTC_KICK0_REG);
|
||||
pm_runtime_put_sync(&pdev->dev);
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
iounmap(rtc_base);
|
||||
fail:
|
||||
release_mem_region(mem->start, resource_size(mem));
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
static int __exit omap_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct rtc_device *rtc = platform_get_drvdata(pdev);
|
||||
struct resource *mem = dev_get_drvdata(&rtc->dev);
|
||||
const struct platform_device_id *id_entry =
|
||||
platform_get_device_id(pdev);
|
||||
|
||||
|
@ -473,12 +454,6 @@ static int __exit omap_rtc_remove(struct platform_device *pdev)
|
|||
/* leave rtc running, but disable irqs */
|
||||
rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
|
||||
|
||||
free_irq(omap_rtc_timer, rtc);
|
||||
|
||||
if (omap_rtc_timer != omap_rtc_alarm)
|
||||
free_irq(omap_rtc_alarm, rtc);
|
||||
|
||||
rtc_device_unregister(rtc);
|
||||
if (id_entry && (id_entry->driver_data & OMAP_RTC_HAS_KICKER))
|
||||
rtc_writel(0, OMAP_RTC_KICK0_REG);
|
||||
|
||||
|
@ -486,16 +461,13 @@ static int __exit omap_rtc_remove(struct platform_device *pdev)
|
|||
pm_runtime_put_sync(&pdev->dev);
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
|
||||
iounmap(rtc_base);
|
||||
release_mem_region(mem->start, resource_size(mem));
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
static u8 irqstat;
|
||||
|
||||
static int omap_rtc_suspend(struct platform_device *pdev, pm_message_t state)
|
||||
static int omap_rtc_suspend(struct device *dev)
|
||||
{
|
||||
irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);
|
||||
|
||||
|
@ -503,34 +475,32 @@ static int omap_rtc_suspend(struct platform_device *pdev, pm_message_t state)
|
|||
* source, and in fact this enable() call is just saving a flag
|
||||
* that's never used...
|
||||
*/
|
||||
if (device_may_wakeup(&pdev->dev))
|
||||
if (device_may_wakeup(dev))
|
||||
enable_irq_wake(omap_rtc_alarm);
|
||||
else
|
||||
rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
|
||||
|
||||
/* Disable the clock/module */
|
||||
pm_runtime_put_sync(&pdev->dev);
|
||||
pm_runtime_put_sync(dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int omap_rtc_resume(struct platform_device *pdev)
|
||||
static int omap_rtc_resume(struct device *dev)
|
||||
{
|
||||
/* Enable the clock/module so that we can access the registers */
|
||||
pm_runtime_get_sync(&pdev->dev);
|
||||
pm_runtime_get_sync(dev);
|
||||
|
||||
if (device_may_wakeup(&pdev->dev))
|
||||
if (device_may_wakeup(dev))
|
||||
disable_irq_wake(omap_rtc_alarm);
|
||||
else
|
||||
rtc_write(irqstat, OMAP_RTC_INTERRUPTS_REG);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#else
|
||||
#define omap_rtc_suspend NULL
|
||||
#define omap_rtc_resume NULL
|
||||
#endif
|
||||
|
||||
static SIMPLE_DEV_PM_OPS(omap_rtc_pm_ops, omap_rtc_suspend, omap_rtc_resume);
|
||||
|
||||
static void omap_rtc_shutdown(struct platform_device *pdev)
|
||||
{
|
||||
rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
|
||||
|
@ -539,28 +509,17 @@ static void omap_rtc_shutdown(struct platform_device *pdev)
|
|||
MODULE_ALIAS("platform:omap_rtc");
|
||||
static struct platform_driver omap_rtc_driver = {
|
||||
.remove = __exit_p(omap_rtc_remove),
|
||||
.suspend = omap_rtc_suspend,
|
||||
.resume = omap_rtc_resume,
|
||||
.shutdown = omap_rtc_shutdown,
|
||||
.driver = {
|
||||
.name = DRIVER_NAME,
|
||||
.owner = THIS_MODULE,
|
||||
.pm = &omap_rtc_pm_ops,
|
||||
.of_match_table = of_match_ptr(omap_rtc_of_match),
|
||||
},
|
||||
.id_table = omap_rtc_devtype,
|
||||
};
|
||||
|
||||
static int __init rtc_init(void)
|
||||
{
|
||||
return platform_driver_probe(&omap_rtc_driver, omap_rtc_probe);
|
||||
}
|
||||
module_init(rtc_init);
|
||||
|
||||
static void __exit rtc_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&omap_rtc_driver);
|
||||
}
|
||||
module_exit(rtc_exit);
|
||||
module_platform_driver_probe(omap_rtc_driver, omap_rtc_probe);
|
||||
|
||||
MODULE_AUTHOR("George G. Davis (and others)");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
|
|
@ -30,6 +30,7 @@
|
|||
#include <linux/kernel.h>
|
||||
#include <linux/mfd/palmas.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/rtc.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/platform_device.h>
|
||||
|
@ -264,7 +265,7 @@ static int palmas_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
palmas_rtc->irq = platform_get_irq(pdev, 0);
|
||||
|
||||
palmas_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
|
||||
palmas_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
|
||||
&palmas_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(palmas_rtc->rtc)) {
|
||||
ret = PTR_ERR(palmas_rtc->rtc);
|
||||
|
@ -272,14 +273,13 @@ static int palmas_rtc_probe(struct platform_device *pdev)
|
|||
return ret;
|
||||
}
|
||||
|
||||
ret = request_threaded_irq(palmas_rtc->irq, NULL,
|
||||
ret = devm_request_threaded_irq(&pdev->dev, palmas_rtc->irq, NULL,
|
||||
palmas_rtc_interrupt,
|
||||
IRQF_TRIGGER_LOW | IRQF_ONESHOT |
|
||||
IRQF_EARLY_RESUME,
|
||||
dev_name(&pdev->dev), palmas_rtc);
|
||||
if (ret < 0) {
|
||||
dev_err(&pdev->dev, "IRQ request failed, err = %d\n", ret);
|
||||
rtc_device_unregister(palmas_rtc->rtc);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -289,11 +289,7 @@ static int palmas_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
static int palmas_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct palmas_rtc *palmas_rtc = platform_get_drvdata(pdev);
|
||||
|
||||
palmas_rtc_alarm_irq_enable(&pdev->dev, 0);
|
||||
free_irq(palmas_rtc->irq, palmas_rtc);
|
||||
rtc_device_unregister(palmas_rtc->rtc);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -321,6 +317,14 @@ static const struct dev_pm_ops palmas_rtc_pm_ops = {
|
|||
SET_SYSTEM_SLEEP_PM_OPS(palmas_rtc_suspend, palmas_rtc_resume)
|
||||
};
|
||||
|
||||
#ifdef CONFIG_OF
|
||||
static struct of_device_id of_palmas_rtc_match[] = {
|
||||
{ .compatible = "ti,palmas-rtc"},
|
||||
{ },
|
||||
};
|
||||
MODULE_DEVICE_TABLE(of, of_palmas_rtc_match);
|
||||
#endif
|
||||
|
||||
static struct platform_driver palmas_rtc_driver = {
|
||||
.probe = palmas_rtc_probe,
|
||||
.remove = palmas_rtc_remove,
|
||||
|
@ -328,6 +332,7 @@ static struct platform_driver palmas_rtc_driver = {
|
|||
.owner = THIS_MODULE,
|
||||
.name = "palmas-rtc",
|
||||
.pm = &palmas_rtc_pm_ops,
|
||||
.of_match_table = of_match_ptr(of_palmas_rtc_match),
|
||||
},
|
||||
};
|
||||
|
||||
|
|
|
@ -139,13 +139,14 @@ static const struct rtc_class_ops pcap_rtc_ops = {
|
|||
.alarm_irq_enable = pcap_rtc_alarm_irq_enable,
|
||||
};
|
||||
|
||||
static int pcap_rtc_probe(struct platform_device *pdev)
|
||||
static int __init pcap_rtc_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct pcap_rtc *pcap_rtc;
|
||||
int timer_irq, alarm_irq;
|
||||
int err = -ENOMEM;
|
||||
|
||||
pcap_rtc = kmalloc(sizeof(struct pcap_rtc), GFP_KERNEL);
|
||||
pcap_rtc = devm_kzalloc(&pdev->dev, sizeof(struct pcap_rtc),
|
||||
GFP_KERNEL);
|
||||
if (!pcap_rtc)
|
||||
return err;
|
||||
|
||||
|
@ -153,68 +154,46 @@ static int pcap_rtc_probe(struct platform_device *pdev)
|
|||
|
||||
platform_set_drvdata(pdev, pcap_rtc);
|
||||
|
||||
pcap_rtc->rtc = rtc_device_register("pcap", &pdev->dev,
|
||||
&pcap_rtc_ops, THIS_MODULE);
|
||||
pcap_rtc->rtc = devm_rtc_device_register(&pdev->dev, "pcap",
|
||||
&pcap_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(pcap_rtc->rtc)) {
|
||||
err = PTR_ERR(pcap_rtc->rtc);
|
||||
goto fail_rtc;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
|
||||
timer_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ);
|
||||
alarm_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA);
|
||||
|
||||
err = request_irq(timer_irq, pcap_rtc_irq, 0, "RTC Timer", pcap_rtc);
|
||||
err = devm_request_irq(&pdev->dev, timer_irq, pcap_rtc_irq, 0,
|
||||
"RTC Timer", pcap_rtc);
|
||||
if (err)
|
||||
goto fail_timer;
|
||||
goto fail;
|
||||
|
||||
err = request_irq(alarm_irq, pcap_rtc_irq, 0, "RTC Alarm", pcap_rtc);
|
||||
err = devm_request_irq(&pdev->dev, alarm_irq, pcap_rtc_irq, 0,
|
||||
"RTC Alarm", pcap_rtc);
|
||||
if (err)
|
||||
goto fail_alarm;
|
||||
goto fail;
|
||||
|
||||
return 0;
|
||||
fail_alarm:
|
||||
free_irq(timer_irq, pcap_rtc);
|
||||
fail_timer:
|
||||
rtc_device_unregister(pcap_rtc->rtc);
|
||||
fail_rtc:
|
||||
fail:
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
kfree(pcap_rtc);
|
||||
return err;
|
||||
}
|
||||
|
||||
static int pcap_rtc_remove(struct platform_device *pdev)
|
||||
static int __exit pcap_rtc_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
|
||||
|
||||
free_irq(pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ), pcap_rtc);
|
||||
free_irq(pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA), pcap_rtc);
|
||||
rtc_device_unregister(pcap_rtc->rtc);
|
||||
kfree(pcap_rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver pcap_rtc_driver = {
|
||||
.remove = pcap_rtc_remove,
|
||||
.remove = __exit_p(pcap_rtc_remove),
|
||||
.driver = {
|
||||
.name = "pcap-rtc",
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init rtc_pcap_init(void)
|
||||
{
|
||||
return platform_driver_probe(&pcap_rtc_driver, pcap_rtc_probe);
|
||||
}
|
||||
|
||||
static void __exit rtc_pcap_exit(void)
|
||||
{
|
||||
platform_driver_unregister(&pcap_rtc_driver);
|
||||
}
|
||||
|
||||
module_init(rtc_pcap_init);
|
||||
module_exit(rtc_pcap_exit);
|
||||
module_platform_driver_probe(pcap_rtc_driver, pcap_rtc_probe);
|
||||
|
||||
MODULE_DESCRIPTION("Motorola pcap rtc driver");
|
||||
MODULE_AUTHOR("guiming zhuo <gmzhuo@gmail.com>");
|
||||
|
|
|
@ -226,7 +226,8 @@ static int pcf2123_probe(struct spi_device *spi)
|
|||
u8 txbuf[2], rxbuf[2];
|
||||
int ret, i;
|
||||
|
||||
pdata = kzalloc(sizeof(struct pcf2123_plat_data), GFP_KERNEL);
|
||||
pdata = devm_kzalloc(&spi->dev, sizeof(struct pcf2123_plat_data),
|
||||
GFP_KERNEL);
|
||||
if (!pdata)
|
||||
return -ENOMEM;
|
||||
spi->dev.platform_data = pdata;
|
||||
|
@ -265,6 +266,7 @@ static int pcf2123_probe(struct spi_device *spi)
|
|||
|
||||
if (!(rxbuf[0] & 0x20)) {
|
||||
dev_err(&spi->dev, "chip not found\n");
|
||||
ret = -ENODEV;
|
||||
goto kfree_exit;
|
||||
}
|
||||
|
||||
|
@ -281,7 +283,7 @@ static int pcf2123_probe(struct spi_device *spi)
|
|||
pcf2123_delay_trec();
|
||||
|
||||
/* Finalize the initialization */
|
||||
rtc = rtc_device_register(pcf2123_driver.driver.name, &spi->dev,
|
||||
rtc = devm_rtc_device_register(&spi->dev, pcf2123_driver.driver.name,
|
||||
&pcf2123_rtc_ops, THIS_MODULE);
|
||||
|
||||
if (IS_ERR(rtc)) {
|
||||
|
@ -314,7 +316,6 @@ sysfs_exit:
|
|||
device_remove_file(&spi->dev, &pdata->regs[i].attr);
|
||||
|
||||
kfree_exit:
|
||||
kfree(pdata);
|
||||
spi->dev.platform_data = NULL;
|
||||
return ret;
|
||||
}
|
||||
|
@ -325,15 +326,10 @@ static int pcf2123_remove(struct spi_device *spi)
|
|||
int i;
|
||||
|
||||
if (pdata) {
|
||||
struct rtc_device *rtc = pdata->rtc;
|
||||
|
||||
if (rtc)
|
||||
rtc_device_unregister(rtc);
|
||||
for (i = 0; i < 16; i++)
|
||||
if (pdata->regs[i].name[0])
|
||||
device_remove_file(&spi->dev,
|
||||
&pdata->regs[i].attr);
|
||||
kfree(pdata);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -252,20 +252,17 @@ static int pcf50633_rtc_probe(struct platform_device *pdev)
|
|||
{
|
||||
struct pcf50633_rtc *rtc;
|
||||
|
||||
rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
|
||||
rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
|
||||
if (!rtc)
|
||||
return -ENOMEM;
|
||||
|
||||
rtc->pcf = dev_to_pcf50633(pdev->dev.parent);
|
||||
platform_set_drvdata(pdev, rtc);
|
||||
rtc->rtc_dev = rtc_device_register("pcf50633-rtc", &pdev->dev,
|
||||
rtc->rtc_dev = devm_rtc_device_register(&pdev->dev, "pcf50633-rtc",
|
||||
&pcf50633_rtc_ops, THIS_MODULE);
|
||||
|
||||
if (IS_ERR(rtc->rtc_dev)) {
|
||||
int ret = PTR_ERR(rtc->rtc_dev);
|
||||
kfree(rtc);
|
||||
return ret;
|
||||
}
|
||||
if (IS_ERR(rtc->rtc_dev))
|
||||
return PTR_ERR(rtc->rtc_dev);
|
||||
|
||||
pcf50633_register_irq(rtc->pcf, PCF50633_IRQ_ALARM,
|
||||
pcf50633_rtc_irq, rtc);
|
||||
|
@ -277,12 +274,8 @@ static int pcf50633_rtc_remove(struct platform_device *pdev)
|
|||
struct pcf50633_rtc *rtc;
|
||||
|
||||
rtc = platform_get_drvdata(pdev);
|
||||
|
||||
pcf50633_free_irq(rtc->pcf, PCF50633_IRQ_ALARM);
|
||||
|
||||
rtc_device_unregister(rtc->rtc_dev);
|
||||
kfree(rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -307,7 +307,7 @@ static int pcf8523_probe(struct i2c_client *client,
|
|||
if (err < 0)
|
||||
return err;
|
||||
|
||||
pcf->rtc = rtc_device_register(DRIVER_NAME, &client->dev,
|
||||
pcf->rtc = devm_rtc_device_register(&client->dev, DRIVER_NAME,
|
||||
&pcf8523_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(pcf->rtc))
|
||||
return PTR_ERR(pcf->rtc);
|
||||
|
@ -319,10 +319,6 @@ static int pcf8523_probe(struct i2c_client *client,
|
|||
|
||||
static int pcf8523_remove(struct i2c_client *client)
|
||||
{
|
||||
struct pcf8523 *pcf = i2c_get_clientdata(client);
|
||||
|
||||
rtc_device_unregister(pcf->rtc);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue