← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to drivers/i2c/busses/i2c-au1550.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/i2c/busses/i2c-au1550.c
36
36
#include <linux/i2c.h>
37
37
#include <linux/slab.h>
38
38
 
39
 
#include <asm/mach-au1x00/au1xxx.h>
 
39
#include <asm/mach-au1x00/au1000.h>
40
40
#include <asm/mach-au1x00/au1xxx_psc.h>
41
41
 
 
42
#define PSC_SEL         0x00
 
43
#define PSC_CTRL        0x04
 
44
#define PSC_SMBCFG      0x08
 
45
#define PSC_SMBMSK      0x0C
 
46
#define PSC_SMBPCR      0x10
 
47
#define PSC_SMBSTAT     0x14
 
48
#define PSC_SMBEVNT     0x18
 
49
#define PSC_SMBTXRX     0x1C
 
50
#define PSC_SMBTMR      0x20
 
51
 
42
52
struct i2c_au1550_data {
43
 
        u32     psc_base;
 
53
        void __iomem *psc_base;
44
54
        int     xfer_timeout;
45
 
        int     ack_timeout;
46
55
        struct i2c_adapter adap;
47
56
        struct resource *ioarea;
48
57
};
49
58
 
50
 
static int
51
 
wait_xfer_done(struct i2c_au1550_data *adap)
52
 
{
53
 
        u32     stat;
54
 
        int     i;
55
 
        volatile psc_smb_t      *sp;
56
 
 
57
 
        sp = (volatile psc_smb_t *)(adap->psc_base);
58
 
 
59
 
        /* Wait for Tx Buffer Empty
60
 
        */
 
59
static inline void WR(struct i2c_au1550_data *a, int r, unsigned long v)
 
60
{
 
61
        __raw_writel(v, a->psc_base + r);
 
62
        wmb();
 
63
}
 
64
 
 
65
static inline unsigned long RD(struct i2c_au1550_data *a, int r)
 
66
{
 
67
        return __raw_readl(a->psc_base + r);
 
68
}
 
69
 
 
70
static int wait_xfer_done(struct i2c_au1550_data *adap)
 
71
{
 
72
        int i;
 
73
 
 
74
        /* Wait for Tx Buffer Empty */
61
75
        for (i = 0; i < adap->xfer_timeout; i++) {
62
 
                stat = sp->psc_smbstat;
63
 
                au_sync();
64
 
                if ((stat & PSC_SMBSTAT_TE) != 0)
 
76
                if (RD(adap, PSC_SMBSTAT) & PSC_SMBSTAT_TE)
65
77
                        return 0;
66
78
 
67
79
                udelay(1);
70
82
        return -ETIMEDOUT;
71
83
}
72
84
 
73
 
static int
74
 
wait_ack(struct i2c_au1550_data *adap)
 
85
static int wait_ack(struct i2c_au1550_data *adap)
75
86
{
76
 
        u32     stat;
77
 
        volatile psc_smb_t      *sp;
 
87
        unsigned long stat;
78
88
 
79
89
        if (wait_xfer_done(adap))
80
90
                return -ETIMEDOUT;
81
91
 
82
 
        sp = (volatile psc_smb_t *)(adap->psc_base);
83
 
 
84
 
        stat = sp->psc_smbevnt;
85
 
        au_sync();
86
 
 
 
92
        stat = RD(adap, PSC_SMBEVNT);
87
93
        if ((stat & (PSC_SMBEVNT_DN | PSC_SMBEVNT_AN | PSC_SMBEVNT_AL)) != 0)
88
94
                return -ETIMEDOUT;
89
95
 
90
96
        return 0;
91
97
}
92
98
 
93
 
static int
94
 
wait_master_done(struct i2c_au1550_data *adap)
 
99
static int wait_master_done(struct i2c_au1550_data *adap)
95
100
{
96
 
        u32     stat;
97
 
        int     i;
98
 
        volatile psc_smb_t      *sp;
99
 
 
100
 
        sp = (volatile psc_smb_t *)(adap->psc_base);
101
 
 
102
 
        /* Wait for Master Done.
103
 
        */
104
 
        for (i = 0; i < adap->xfer_timeout; i++) {
105
 
                stat = sp->psc_smbevnt;
106
 
                au_sync();
107
 
                if ((stat & PSC_SMBEVNT_MD) != 0)
 
101
        int i;
 
102
 
 
103
        /* Wait for Master Done. */
 
104
        for (i = 0; i < 2 * adap->xfer_timeout; i++) {
 
105
                if ((RD(adap, PSC_SMBEVNT) & PSC_SMBEVNT_MD) != 0)
108
106
                        return 0;
109
107
                udelay(1);
110
108
        }
115
113
static int
116
114
do_address(struct i2c_au1550_data *adap, unsigned int addr, int rd, int q)
117
115
{
118
 
        volatile psc_smb_t      *sp;
119
 
        u32                     stat;
120
 
 
121
 
        sp = (volatile psc_smb_t *)(adap->psc_base);
122
 
 
123
 
        /* Reset the FIFOs, clear events.
124
 
        */
125
 
        stat = sp->psc_smbstat;
126
 
        sp->psc_smbevnt = PSC_SMBEVNT_ALLCLR;
127
 
        au_sync();
 
116
        unsigned long stat;
 
117
 
 
118
        /* Reset the FIFOs, clear events. */
 
119
        stat = RD(adap, PSC_SMBSTAT);
 
120
        WR(adap, PSC_SMBEVNT, PSC_SMBEVNT_ALLCLR);
128
121
 
129
122
        if (!(stat & PSC_SMBSTAT_TE) || !(stat & PSC_SMBSTAT_RE)) {
130
 
                sp->psc_smbpcr = PSC_SMBPCR_DC;
131
 
                au_sync();
132
 
                do {
133
 
                        stat = sp->psc_smbpcr;
134
 
                        au_sync();
135
 
                } while ((stat & PSC_SMBPCR_DC) != 0);
 
123
                WR(adap, PSC_SMBPCR, PSC_SMBPCR_DC);
 
124
                while ((RD(adap, PSC_SMBPCR) & PSC_SMBPCR_DC) != 0)
 
125
                        cpu_relax();
136
126
                udelay(50);
137
127
        }
138
128
 
139
 
        /* Write out the i2c chip address and specify operation
140
 
        */
 
129
        /* Write out the i2c chip address and specify operation */
141
130
        addr <<= 1;
142
131
        if (rd)
143
132
                addr |= 1;
146
135
        if (q)
147
136
                addr |= PSC_SMBTXRX_STP;
148
137
 
149
 
        /* Put byte into fifo, start up master.
150
 
        */
151
 
        sp->psc_smbtxrx = addr;
152
 
        au_sync();
153
 
        sp->psc_smbpcr = PSC_SMBPCR_MS;
154
 
        au_sync();
 
138
        /* Put byte into fifo, start up master. */
 
139
        WR(adap, PSC_SMBTXRX, addr);
 
140
        WR(adap, PSC_SMBPCR, PSC_SMBPCR_MS);
155
141
        if (wait_ack(adap))
156
142
                return -EIO;
157
143
        return (q) ? wait_master_done(adap) : 0;
158
144
}
159
145
 
160
 
static u32
161
 
wait_for_rx_byte(struct i2c_au1550_data *adap, u32 *ret_data)
 
146
static int wait_for_rx_byte(struct i2c_au1550_data *adap, unsigned char *out)
162
147
{
163
 
        int     j;
164
 
        u32     data, stat;
165
 
        volatile psc_smb_t      *sp;
 
148
        int j;
166
149
 
167
150
        if (wait_xfer_done(adap))
168
151
                return -EIO;
169
152
 
170
 
        sp = (volatile psc_smb_t *)(adap->psc_base);
171
 
 
172
153
        j =  adap->xfer_timeout * 100;
173
154
        do {
174
155
                j--;
175
156
                if (j <= 0)
176
157
                        return -EIO;
177
158
 
178
 
                stat = sp->psc_smbstat;
179
 
                au_sync();
180
 
                if ((stat & PSC_SMBSTAT_RE) == 0)
 
159
                if ((RD(adap, PSC_SMBSTAT) & PSC_SMBSTAT_RE) == 0)
181
160
                        j = 0;
182
161
                else
183
162
                        udelay(1);
184
163
        } while (j > 0);
185
 
        data = sp->psc_smbtxrx;
186
 
        au_sync();
187
 
        *ret_data = data;
 
164
 
 
165
        *out = RD(adap, PSC_SMBTXRX);
188
166
 
189
167
        return 0;
190
168
}
191
169
 
192
 
static int
193
 
i2c_read(struct i2c_au1550_data *adap, unsigned char *buf,
 
170
static int i2c_read(struct i2c_au1550_data *adap, unsigned char *buf,
194
171
                    unsigned int len)
195
172
{
196
 
        int     i;
197
 
        u32     data;
198
 
        volatile psc_smb_t      *sp;
 
173
        int i;
199
174
 
200
175
        if (len == 0)
201
176
                return 0;
204
179
         * zero bytes for timing, waiting for bytes to appear in the
205
180
         * receive fifo, then reading the bytes.
206
181
         */
207
 
 
208
 
        sp = (volatile psc_smb_t *)(adap->psc_base);
209
 
 
210
182
        i = 0;
211
 
        while (i < (len-1)) {
212
 
                sp->psc_smbtxrx = 0;
213
 
                au_sync();
214
 
                if (wait_for_rx_byte(adap, &data))
 
183
        while (i < (len - 1)) {
 
184
                WR(adap, PSC_SMBTXRX, 0);
 
185
                if (wait_for_rx_byte(adap, &buf[i]))
215
186
                        return -EIO;
216
187
 
217
 
                buf[i] = data;
218
188
                i++;
219
189
        }
220
190
 
221
 
        /* The last byte has to indicate transfer done.
222
 
        */
223
 
        sp->psc_smbtxrx = PSC_SMBTXRX_STP;
224
 
        au_sync();
 
191
        /* The last byte has to indicate transfer done. */
 
192
        WR(adap, PSC_SMBTXRX, PSC_SMBTXRX_STP);
225
193
        if (wait_master_done(adap))
226
194
                return -EIO;
227
195
 
228
 
        data = sp->psc_smbtxrx;
229
 
        au_sync();
230
 
        buf[i] = data;
 
196
        buf[i] = (unsigned char)(RD(adap, PSC_SMBTXRX) & 0xff);
231
197
        return 0;
232
198
}
233
199
 
234
 
static int
235
 
i2c_write(struct i2c_au1550_data *adap, unsigned char *buf,
 
200
static int i2c_write(struct i2c_au1550_data *adap, unsigned char *buf,
236
201
                     unsigned int len)
237
202
{
238
 
        int     i;
239
 
        u32     data;
240
 
        volatile psc_smb_t      *sp;
 
203
        int i;
 
204
        unsigned long data;
241
205
 
242
206
        if (len == 0)
243
207
                return 0;
244
208
 
245
 
        sp = (volatile psc_smb_t *)(adap->psc_base);
246
 
 
247
209
        i = 0;
248
210
        while (i < (len-1)) {
249
211
                data = buf[i];
250
 
                sp->psc_smbtxrx = data;
251
 
                au_sync();
 
212
                WR(adap, PSC_SMBTXRX, data);
252
213
                if (wait_ack(adap))
253
214
                        return -EIO;
254
215
                i++;
255
216
        }
256
217
 
257
 
        /* The last byte has to indicate transfer done.
258
 
        */
 
218
        /* The last byte has to indicate transfer done. */
259
219
        data = buf[i];
260
220
        data |= PSC_SMBTXRX_STP;
261
 
        sp->psc_smbtxrx = data;
262
 
        au_sync();
 
221
        WR(adap, PSC_SMBTXRX, data);
263
222
        if (wait_master_done(adap))
264
223
                return -EIO;
265
224
        return 0;
269
228
au1550_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
270
229
{
271
230
        struct i2c_au1550_data *adap = i2c_adap->algo_data;
272
 
        volatile psc_smb_t *sp = (volatile psc_smb_t *)adap->psc_base;
273
231
        struct i2c_msg *p;
274
232
        int i, err = 0;
275
233
 
276
 
        sp->psc_ctrl = PSC_CTRL_ENABLE;
277
 
        au_sync();
 
234
        WR(adap, PSC_CTRL, PSC_CTRL_ENABLE);
278
235
 
279
236
        for (i = 0; !err && i < num; i++) {
280
237
                p = &msgs[i];
293
250
        if (err == 0)
294
251
                err = num;
295
252
 
296
 
        sp->psc_ctrl = PSC_CTRL_SUSPEND;
297
 
        au_sync();
 
253
        WR(adap, PSC_CTRL, PSC_CTRL_SUSPEND);
298
254
 
299
255
        return err;
300
256
}
301
257
 
302
 
static u32
303
 
au1550_func(struct i2c_adapter *adap)
 
258
static u32 au1550_func(struct i2c_adapter *adap)
304
259
{
305
260
        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
306
261
}
312
267
 
313
268
static void i2c_au1550_setup(struct i2c_au1550_data *priv)
314
269
{
315
 
        volatile psc_smb_t *sp = (volatile psc_smb_t *)priv->psc_base;
316
 
        u32 stat;
317
 
 
318
 
        sp->psc_ctrl = PSC_CTRL_DISABLE;
319
 
        au_sync();
320
 
        sp->psc_sel = PSC_SEL_PS_SMBUSMODE;
321
 
        sp->psc_smbcfg = 0;
322
 
        au_sync();
323
 
        sp->psc_ctrl = PSC_CTRL_ENABLE;
324
 
        au_sync();
325
 
        do {
326
 
                stat = sp->psc_smbstat;
327
 
                au_sync();
328
 
        } while ((stat & PSC_SMBSTAT_SR) == 0);
329
 
 
330
 
        sp->psc_smbcfg = (PSC_SMBCFG_RT_FIFO8 | PSC_SMBCFG_TT_FIFO8 |
331
 
                                PSC_SMBCFG_DD_DISABLE);
 
270
        unsigned long cfg;
 
271
 
 
272
        WR(priv, PSC_CTRL, PSC_CTRL_DISABLE);
 
273
        WR(priv, PSC_SEL, PSC_SEL_PS_SMBUSMODE);
 
274
        WR(priv, PSC_SMBCFG, 0);
 
275
        WR(priv, PSC_CTRL, PSC_CTRL_ENABLE);
 
276
        while ((RD(priv, PSC_SMBSTAT) & PSC_SMBSTAT_SR) == 0)
 
277
                cpu_relax();
 
278
 
 
279
        cfg = PSC_SMBCFG_RT_FIFO8 | PSC_SMBCFG_TT_FIFO8 | PSC_SMBCFG_DD_DISABLE;
 
280
        WR(priv, PSC_SMBCFG, cfg);
332
281
 
333
282
        /* Divide by 8 to get a 6.25 MHz clock.  The later protocol
334
283
         * timings are based on this clock.
335
284
         */
336
 
        sp->psc_smbcfg |= PSC_SMBCFG_SET_DIV(PSC_SMBCFG_DIV8);
337
 
        sp->psc_smbmsk = PSC_SMBMSK_ALLMASK;
338
 
        au_sync();
 
285
        cfg |= PSC_SMBCFG_SET_DIV(PSC_SMBCFG_DIV8);
 
286
        WR(priv, PSC_SMBCFG, cfg);
 
287
        WR(priv, PSC_SMBMSK, PSC_SMBMSK_ALLMASK);
339
288
 
340
289
        /* Set the protocol timer values.  See Table 71 in the
341
290
         * Au1550 Data Book for standard timing values.
342
291
         */
343
 
        sp->psc_smbtmr = PSC_SMBTMR_SET_TH(0) | PSC_SMBTMR_SET_PS(15) | \
 
292
        WR(priv, PSC_SMBTMR, PSC_SMBTMR_SET_TH(0) | PSC_SMBTMR_SET_PS(15) | \
344
293
                PSC_SMBTMR_SET_PU(15) | PSC_SMBTMR_SET_SH(15) | \
345
294
                PSC_SMBTMR_SET_SU(15) | PSC_SMBTMR_SET_CL(15) | \
346
 
                PSC_SMBTMR_SET_CH(15);
347
 
        au_sync();
348
 
 
349
 
        sp->psc_smbcfg |= PSC_SMBCFG_DE_ENABLE;
350
 
        do {
351
 
                stat = sp->psc_smbstat;
352
 
                au_sync();
353
 
        } while ((stat & PSC_SMBSTAT_SR) == 0);
354
 
 
355
 
        sp->psc_ctrl = PSC_CTRL_SUSPEND;
356
 
        au_sync();
 
295
                PSC_SMBTMR_SET_CH(15));
 
296
 
 
297
        cfg |= PSC_SMBCFG_DE_ENABLE;
 
298
        WR(priv, PSC_SMBCFG, cfg);
 
299
        while ((RD(priv, PSC_SMBSTAT) & PSC_SMBSTAT_SR) == 0)
 
300
                cpu_relax();
 
301
 
 
302
        WR(priv, PSC_CTRL, PSC_CTRL_SUSPEND);
357
303
}
358
304
 
359
305
static void i2c_au1550_disable(struct i2c_au1550_data *priv)
360
306
{
361
 
        volatile psc_smb_t *sp = (volatile psc_smb_t *)priv->psc_base;
362
 
 
363
 
        sp->psc_smbcfg = 0;
364
 
        sp->psc_ctrl = PSC_CTRL_DISABLE;
365
 
        au_sync();
 
307
        WR(priv, PSC_SMBCFG, 0);
 
308
        WR(priv, PSC_CTRL, PSC_CTRL_DISABLE);
366
309
}
367
310
 
368
311
/*
396
339
                goto out_mem;
397
340
        }
398
341
 
399
 
        priv->psc_base = CKSEG1ADDR(r->start);
 
342
        priv->psc_base = ioremap(r->start, resource_size(r));
 
343
        if (!priv->psc_base) {
 
344
                ret = -EIO;
 
345
                goto out_map;
 
346
        }
400
347
        priv->xfer_timeout = 200;
401
 
        priv->ack_timeout = 200;
402
348
 
403
349
        priv->adap.nr = pdev->id;
404
350
        priv->adap.algo = &au1550_algo;
406
352
        priv->adap.dev.parent = &pdev->dev;
407
353
        strlcpy(priv->adap.name, "Au1xxx PSC I2C", sizeof(priv->adap.name));
408
354
 
409
 
        /* Now, set up the PSC for SMBus PIO mode.
410
 
        */
 
355
        /* Now, set up the PSC for SMBus PIO mode. */
411
356
        i2c_au1550_setup(priv);
412
357
 
413
358
        ret = i2c_add_numbered_adapter(&priv->adap);
417
362
        }
418
363
 
419
364
        i2c_au1550_disable(priv);
420
 
 
 
365
        iounmap(priv->psc_base);
 
366
out_map:
421
367
        release_resource(priv->ioarea);
422
368
        kfree(priv->ioarea);
423
369
out_mem:
426
372
        return ret;
427
373
}
428
374
 
429
 
static int __devexit
430
 
i2c_au1550_remove(struct platform_device *pdev)
 
375
static int __devexit i2c_au1550_remove(struct platform_device *pdev)
431
376
{
432
377
        struct i2c_au1550_data *priv = platform_get_drvdata(pdev);
433
378
 
434
379
        platform_set_drvdata(pdev, NULL);
435
380
        i2c_del_adapter(&priv->adap);
436
381
        i2c_au1550_disable(priv);
 
382
        iounmap(priv->psc_base);
437
383
        release_resource(priv->ioarea);
438
384
        kfree(priv->ioarea);
439
385
        kfree(priv);
441
387
}
442
388
 
443
389
#ifdef CONFIG_PM
444
 
static int
445
 
i2c_au1550_suspend(struct platform_device *pdev, pm_message_t state)
 
390
static int i2c_au1550_suspend(struct device *dev)
446
391
{
447
 
        struct i2c_au1550_data *priv = platform_get_drvdata(pdev);
 
392
        struct i2c_au1550_data *priv = dev_get_drvdata(dev);
448
393
 
449
394
        i2c_au1550_disable(priv);
450
395
 
451
396
        return 0;
452
397
}
453
398
 
454
 
static int
455
 
i2c_au1550_resume(struct platform_device *pdev)
 
399
static int i2c_au1550_resume(struct device *dev)
456
400
{
457
 
        struct i2c_au1550_data *priv = platform_get_drvdata(pdev);
 
401
        struct i2c_au1550_data *priv = dev_get_drvdata(dev);
458
402
 
459
403
        i2c_au1550_setup(priv);
460
404
 
461
405
        return 0;
462
406
}
 
407
 
 
408
static const struct dev_pm_ops i2c_au1550_pmops = {
 
409
        .suspend        = i2c_au1550_suspend,
 
410
        .resume         = i2c_au1550_resume,
 
411
};
 
412
 
 
413
#define AU1XPSC_SMBUS_PMOPS (&i2c_au1550_pmops)
 
414
 
463
415
#else
464
 
#define i2c_au1550_suspend      NULL
465
 
#define i2c_au1550_resume       NULL
 
416
#define AU1XPSC_SMBUS_PMOPS NULL
466
417
#endif
467
418
 
468
419
static struct platform_driver au1xpsc_smbus_driver = {
469
420
        .driver = {
470
421
                .name   = "au1xpsc_smbus",
471
422
                .owner  = THIS_MODULE,
 
423
                .pm     = AU1XPSC_SMBUS_PMOPS,
472
424
        },
473
425
        .probe          = i2c_au1550_probe,
474
426
        .remove         = __devexit_p(i2c_au1550_remove),
475
 
        .suspend        = i2c_au1550_suspend,
476
 
        .resume         = i2c_au1550_resume,
477
427
};
478
428
 
479
 
static int __init
480
 
i2c_au1550_init(void)
 
429
static int __init i2c_au1550_init(void)
481
430
{
482
431
        return platform_driver_register(&au1xpsc_smbus_driver);
483
432
}
484
433
 
485
 
static void __exit
486
 
i2c_au1550_exit(void)
 
434
static void __exit i2c_au1550_exit(void)
487
435
{
488
436
        platform_driver_unregister(&au1xpsc_smbus_driver);
489
437
}