← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/s390/cio/css.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/s390/cio/css.c
 
1
/*
 
2
 * driver for channel subsystem
 
3
 *
 
4
 * Copyright IBM Corp. 2002, 2010
 
5
 *
 
6
 * Author(s): Arnd Bergmann (arndb@de.ibm.com)
 
7
 *            Cornelia Huck (cornelia.huck@de.ibm.com)
 
8
 */
 
9
 
 
10
#define KMSG_COMPONENT "cio"
 
11
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
12
 
 
13
#include <linux/module.h>
 
14
#include <linux/init.h>
 
15
#include <linux/device.h>
 
16
#include <linux/slab.h>
 
17
#include <linux/errno.h>
 
18
#include <linux/list.h>
 
19
#include <linux/reboot.h>
 
20
#include <linux/suspend.h>
 
21
#include <linux/proc_fs.h>
 
22
#include <asm/isc.h>
 
23
#include <asm/crw.h>
 
24
 
 
25
#include "css.h"
 
26
#include "cio.h"
 
27
#include "cio_debug.h"
 
28
#include "ioasm.h"
 
29
#include "chsc.h"
 
30
#include "device.h"
 
31
#include "idset.h"
 
32
#include "chp.h"
 
33
 
 
34
int css_init_done = 0;
 
35
int max_ssid;
 
36
 
 
37
struct channel_subsystem *channel_subsystems[__MAX_CSSID + 1];
 
38
static struct bus_type css_bus_type;
 
39
 
 
40
int
 
41
for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *data)
 
42
{
 
43
        struct subchannel_id schid;
 
44
        int ret;
 
45
 
 
46
        init_subchannel_id(&schid);
 
47
        ret = -ENODEV;
 
48
        do {
 
49
                do {
 
50
                        ret = fn(schid, data);
 
51
                        if (ret)
 
52
                                break;
 
53
                } while (schid.sch_no++ < __MAX_SUBCHANNEL);
 
54
                schid.sch_no = 0;
 
55
        } while (schid.ssid++ < max_ssid);
 
56
        return ret;
 
57
}
 
58
 
 
59
struct cb_data {
 
60
        void *data;
 
61
        struct idset *set;
 
62
        int (*fn_known_sch)(struct subchannel *, void *);
 
63
        int (*fn_unknown_sch)(struct subchannel_id, void *);
 
64
};
 
65
 
 
66
static int call_fn_known_sch(struct device *dev, void *data)
 
67
{
 
68
        struct subchannel *sch = to_subchannel(dev);
 
69
        struct cb_data *cb = data;
 
70
        int rc = 0;
 
71
 
 
72
        idset_sch_del(cb->set, sch->schid);
 
73
        if (cb->fn_known_sch)
 
74
                rc = cb->fn_known_sch(sch, cb->data);
 
75
        return rc;
 
76
}
 
77
 
 
78
static int call_fn_unknown_sch(struct subchannel_id schid, void *data)
 
79
{
 
80
        struct cb_data *cb = data;
 
81
        int rc = 0;
 
82
 
 
83
        if (idset_sch_contains(cb->set, schid))
 
84
                rc = cb->fn_unknown_sch(schid, cb->data);
 
85
        return rc;
 
86
}
 
87
 
 
88
static int call_fn_all_sch(struct subchannel_id schid, void *data)
 
89
{
 
90
        struct cb_data *cb = data;
 
91
        struct subchannel *sch;
 
92
        int rc = 0;
 
93
 
 
94
        sch = get_subchannel_by_schid(schid);
 
95
        if (sch) {
 
96
                if (cb->fn_known_sch)
 
97
                        rc = cb->fn_known_sch(sch, cb->data);
 
98
                put_device(&sch->dev);
 
99
        } else {
 
100
                if (cb->fn_unknown_sch)
 
101
                        rc = cb->fn_unknown_sch(schid, cb->data);
 
102
        }
 
103
 
 
104
        return rc;
 
105
}
 
106
 
 
107
int for_each_subchannel_staged(int (*fn_known)(struct subchannel *, void *),
 
108
                               int (*fn_unknown)(struct subchannel_id,
 
109
                               void *), void *data)
 
110
{
 
111
        struct cb_data cb;
 
112
        int rc;
 
113
 
 
114
        cb.data = data;
 
115
        cb.fn_known_sch = fn_known;
 
116
        cb.fn_unknown_sch = fn_unknown;
 
117
 
 
118
        cb.set = idset_sch_new();
 
119
        if (!cb.set)
 
120
                /* fall back to brute force scanning in case of oom */
 
121
                return for_each_subchannel(call_fn_all_sch, &cb);
 
122
 
 
123
        idset_fill(cb.set);
 
124
 
 
125
        /* Process registered subchannels. */
 
126
        rc = bus_for_each_dev(&css_bus_type, NULL, &cb, call_fn_known_sch);
 
127
        if (rc)
 
128
                goto out;
 
129
        /* Process unregistered subchannels. */
 
130
        if (fn_unknown)
 
131
                rc = for_each_subchannel(call_fn_unknown_sch, &cb);
 
132
out:
 
133
        idset_free(cb.set);
 
134
 
 
135
        return rc;
 
136
}
 
137
 
 
138
static void css_sch_todo(struct work_struct *work);
 
139
 
 
140
static struct subchannel *
 
141
css_alloc_subchannel(struct subchannel_id schid)
 
142
{
 
143
        struct subchannel *sch;
 
144
        int ret;
 
145
 
 
146
        sch = kmalloc (sizeof (*sch), GFP_KERNEL | GFP_DMA);
 
147
        if (sch == NULL)
 
148
                return ERR_PTR(-ENOMEM);
 
149
        ret = cio_validate_subchannel (sch, schid);
 
150
        if (ret < 0) {
 
151
                kfree(sch);
 
152
                return ERR_PTR(ret);
 
153
        }
 
154
        INIT_WORK(&sch->todo_work, css_sch_todo);
 
155
        return sch;
 
156
}
 
157
 
 
158
static void
 
159
css_subchannel_release(struct device *dev)
 
160
{
 
161
        struct subchannel *sch;
 
162
 
 
163
        sch = to_subchannel(dev);
 
164
        if (!cio_is_console(sch->schid)) {
 
165
                /* Reset intparm to zeroes. */
 
166
                sch->config.intparm = 0;
 
167
                cio_commit_config(sch);
 
168
                kfree(sch->lock);
 
169
                kfree(sch);
 
170
        }
 
171
}
 
172
 
 
173
static int css_sch_device_register(struct subchannel *sch)
 
174
{
 
175
        int ret;
 
176
 
 
177
        mutex_lock(&sch->reg_mutex);
 
178
        dev_set_name(&sch->dev, "0.%x.%04x", sch->schid.ssid,
 
179
                     sch->schid.sch_no);
 
180
        ret = device_register(&sch->dev);
 
181
        mutex_unlock(&sch->reg_mutex);
 
182
        return ret;
 
183
}
 
184
 
 
185
/**
 
186
 * css_sch_device_unregister - unregister a subchannel
 
187
 * @sch: subchannel to be unregistered
 
188
 */
 
189
void css_sch_device_unregister(struct subchannel *sch)
 
190
{
 
191
        mutex_lock(&sch->reg_mutex);
 
192
        if (device_is_registered(&sch->dev))
 
193
                device_unregister(&sch->dev);
 
194
        mutex_unlock(&sch->reg_mutex);
 
195
}
 
196
EXPORT_SYMBOL_GPL(css_sch_device_unregister);
 
197
 
 
198
static void ssd_from_pmcw(struct chsc_ssd_info *ssd, struct pmcw *pmcw)
 
199
{
 
200
        int i;
 
201
        int mask;
 
202
 
 
203
        memset(ssd, 0, sizeof(struct chsc_ssd_info));
 
204
        ssd->path_mask = pmcw->pim;
 
205
        for (i = 0; i < 8; i++) {
 
206
                mask = 0x80 >> i;
 
207
                if (pmcw->pim & mask) {
 
208
                        chp_id_init(&ssd->chpid[i]);
 
209
                        ssd->chpid[i].id = pmcw->chpid[i];
 
210
                }
 
211
        }
 
212
}
 
213
 
 
214
static void ssd_register_chpids(struct chsc_ssd_info *ssd)
 
215
{
 
216
        int i;
 
217
        int mask;
 
218
 
 
219
        for (i = 0; i < 8; i++) {
 
220
                mask = 0x80 >> i;
 
221
                if (ssd->path_mask & mask)
 
222
                        if (!chp_is_registered(ssd->chpid[i]))
 
223
                                chp_new(ssd->chpid[i]);
 
224
        }
 
225
}
 
226
 
 
227
void css_update_ssd_info(struct subchannel *sch)
 
228
{
 
229
        int ret;
 
230
 
 
231
        if (cio_is_console(sch->schid)) {
 
232
                /* Console is initialized too early for functions requiring
 
233
                 * memory allocation. */
 
234
                ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw);
 
235
        } else {
 
236
                ret = chsc_get_ssd_info(sch->schid, &sch->ssd_info);
 
237
                if (ret)
 
238
                        ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw);
 
239
                ssd_register_chpids(&sch->ssd_info);
 
240
        }
 
241
}
 
242
 
 
243
static ssize_t type_show(struct device *dev, struct device_attribute *attr,
 
244
                         char *buf)
 
245
{
 
246
        struct subchannel *sch = to_subchannel(dev);
 
247
 
 
248
        return sprintf(buf, "%01x\n", sch->st);
 
249
}
 
250
 
 
251
static DEVICE_ATTR(type, 0444, type_show, NULL);
 
252
 
 
253
static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
 
254
                             char *buf)
 
255
{
 
256
        struct subchannel *sch = to_subchannel(dev);
 
257
 
 
258
        return sprintf(buf, "css:t%01X\n", sch->st);
 
259
}
 
260
 
 
261
static DEVICE_ATTR(modalias, 0444, modalias_show, NULL);
 
262
 
 
263
static struct attribute *subch_attrs[] = {
 
264
        &dev_attr_type.attr,
 
265
        &dev_attr_modalias.attr,
 
266
        NULL,
 
267
};
 
268
 
 
269
static struct attribute_group subch_attr_group = {
 
270
        .attrs = subch_attrs,
 
271
};
 
272
 
 
273
static const struct attribute_group *default_subch_attr_groups[] = {
 
274
        &subch_attr_group,
 
275
        NULL,
 
276
};
 
277
 
 
278
static int css_register_subchannel(struct subchannel *sch)
 
279
{
 
280
        int ret;
 
281
 
 
282
        /* Initialize the subchannel structure */
 
283
        sch->dev.parent = &channel_subsystems[0]->device;
 
284
        sch->dev.bus = &css_bus_type;
 
285
        sch->dev.release = &css_subchannel_release;
 
286
        sch->dev.groups = default_subch_attr_groups;
 
287
        /*
 
288
         * We don't want to generate uevents for I/O subchannels that don't
 
289
         * have a working ccw device behind them since they will be
 
290
         * unregistered before they can be used anyway, so we delay the add
 
291
         * uevent until after device recognition was successful.
 
292
         * Note that we suppress the uevent for all subchannel types;
 
293
         * the subchannel driver can decide itself when it wants to inform
 
294
         * userspace of its existence.
 
295
         */
 
296
        dev_set_uevent_suppress(&sch->dev, 1);
 
297
        css_update_ssd_info(sch);
 
298
        /* make it known to the system */
 
299
        ret = css_sch_device_register(sch);
 
300
        if (ret) {
 
301
                CIO_MSG_EVENT(0, "Could not register sch 0.%x.%04x: %d\n",
 
302
                              sch->schid.ssid, sch->schid.sch_no, ret);
 
303
                return ret;
 
304
        }
 
305
        if (!sch->driver) {
 
306
                /*
 
307
                 * No driver matched. Generate the uevent now so that
 
308
                 * a fitting driver module may be loaded based on the
 
309
                 * modalias.
 
310
                 */
 
311
                dev_set_uevent_suppress(&sch->dev, 0);
 
312
                kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
 
313
        }
 
314
        return ret;
 
315
}
 
316
 
 
317
int css_probe_device(struct subchannel_id schid)
 
318
{
 
319
        int ret;
 
320
        struct subchannel *sch;
 
321
 
 
322
        if (cio_is_console(schid))
 
323
                sch = cio_get_console_subchannel();
 
324
        else {
 
325
                sch = css_alloc_subchannel(schid);
 
326
                if (IS_ERR(sch))
 
327
                        return PTR_ERR(sch);
 
328
        }
 
329
        ret = css_register_subchannel(sch);
 
330
        if (ret) {
 
331
                if (!cio_is_console(schid))
 
332
                        put_device(&sch->dev);
 
333
        }
 
334
        return ret;
 
335
}
 
336
 
 
337
static int
 
338
check_subchannel(struct device * dev, void * data)
 
339
{
 
340
        struct subchannel *sch;
 
341
        struct subchannel_id *schid = data;
 
342
 
 
343
        sch = to_subchannel(dev);
 
344
        return schid_equal(&sch->schid, schid);
 
345
}
 
346
 
 
347
struct subchannel *
 
348
get_subchannel_by_schid(struct subchannel_id schid)
 
349
{
 
350
        struct device *dev;
 
351
 
 
352
        dev = bus_find_device(&css_bus_type, NULL,
 
353
                              &schid, check_subchannel);
 
354
 
 
355
        return dev ? to_subchannel(dev) : NULL;
 
356
}
 
357
 
 
358
/**
 
359
 * css_sch_is_valid() - check if a subchannel is valid
 
360
 * @schib: subchannel information block for the subchannel
 
361
 */
 
362
int css_sch_is_valid(struct schib *schib)
 
363
{
 
364
        if ((schib->pmcw.st == SUBCHANNEL_TYPE_IO) && !schib->pmcw.dnv)
 
365
                return 0;
 
366
        if ((schib->pmcw.st == SUBCHANNEL_TYPE_MSG) && !schib->pmcw.w)
 
367
                return 0;
 
368
        return 1;
 
369
}
 
370
EXPORT_SYMBOL_GPL(css_sch_is_valid);
 
371
 
 
372
static int css_evaluate_new_subchannel(struct subchannel_id schid, int slow)
 
373
{
 
374
        struct schib schib;
 
375
 
 
376
        if (!slow) {
 
377
                /* Will be done on the slow path. */
 
378
                return -EAGAIN;
 
379
        }
 
380
        if (stsch_err(schid, &schib) || !css_sch_is_valid(&schib)) {
 
381
                /* Unusable - ignore. */
 
382
                return 0;
 
383
        }
 
384
        CIO_MSG_EVENT(4, "event: sch 0.%x.%04x, new\n", schid.ssid,
 
385
                      schid.sch_no);
 
386
 
 
387
        return css_probe_device(schid);
 
388
}
 
389
 
 
390
static int css_evaluate_known_subchannel(struct subchannel *sch, int slow)
 
391
{
 
392
        int ret = 0;
 
393
 
 
394
        if (sch->driver) {
 
395
                if (sch->driver->sch_event)
 
396
                        ret = sch->driver->sch_event(sch, slow);
 
397
                else
 
398
                        dev_dbg(&sch->dev,
 
399
                                "Got subchannel machine check but "
 
400
                                "no sch_event handler provided.\n");
 
401
        }
 
402
        if (ret != 0 && ret != -EAGAIN) {
 
403
                CIO_MSG_EVENT(2, "eval: sch 0.%x.%04x, rc=%d\n",
 
404
                              sch->schid.ssid, sch->schid.sch_no, ret);
 
405
        }
 
406
        return ret;
 
407
}
 
408
 
 
409
static void css_evaluate_subchannel(struct subchannel_id schid, int slow)
 
410
{
 
411
        struct subchannel *sch;
 
412
        int ret;
 
413
 
 
414
        sch = get_subchannel_by_schid(schid);
 
415
        if (sch) {
 
416
                ret = css_evaluate_known_subchannel(sch, slow);
 
417
                put_device(&sch->dev);
 
418
        } else
 
419
                ret = css_evaluate_new_subchannel(schid, slow);
 
420
        if (ret == -EAGAIN)
 
421
                css_schedule_eval(schid);
 
422
}
 
423
 
 
424
/**
 
425
 * css_sched_sch_todo - schedule a subchannel operation
 
426
 * @sch: subchannel
 
427
 * @todo: todo
 
428
 *
 
429
 * Schedule the operation identified by @todo to be performed on the slow path
 
430
 * workqueue. Do nothing if another operation with higher priority is already
 
431
 * scheduled. Needs to be called with subchannel lock held.
 
432
 */
 
433
void css_sched_sch_todo(struct subchannel *sch, enum sch_todo todo)
 
434
{
 
435
        CIO_MSG_EVENT(4, "sch_todo: sched sch=0.%x.%04x todo=%d\n",
 
436
                      sch->schid.ssid, sch->schid.sch_no, todo);
 
437
        if (sch->todo >= todo)
 
438
                return;
 
439
        /* Get workqueue ref. */
 
440
        if (!get_device(&sch->dev))
 
441
                return;
 
442
        sch->todo = todo;
 
443
        if (!queue_work(cio_work_q, &sch->todo_work)) {
 
444
                /* Already queued, release workqueue ref. */
 
445
                put_device(&sch->dev);
 
446
        }
 
447
}
 
448
 
 
449
static void css_sch_todo(struct work_struct *work)
 
450
{
 
451
        struct subchannel *sch;
 
452
        enum sch_todo todo;
 
453
        int ret;
 
454
 
 
455
        sch = container_of(work, struct subchannel, todo_work);
 
456
        /* Find out todo. */
 
457
        spin_lock_irq(sch->lock);
 
458
        todo = sch->todo;
 
459
        CIO_MSG_EVENT(4, "sch_todo: sch=0.%x.%04x, todo=%d\n", sch->schid.ssid,
 
460
                      sch->schid.sch_no, todo);
 
461
        sch->todo = SCH_TODO_NOTHING;
 
462
        spin_unlock_irq(sch->lock);
 
463
        /* Perform todo. */
 
464
        switch (todo) {
 
465
        case SCH_TODO_NOTHING:
 
466
                break;
 
467
        case SCH_TODO_EVAL:
 
468
                ret = css_evaluate_known_subchannel(sch, 1);
 
469
                if (ret == -EAGAIN) {
 
470
                        spin_lock_irq(sch->lock);
 
471
                        css_sched_sch_todo(sch, todo);
 
472
                        spin_unlock_irq(sch->lock);
 
473
                }
 
474
                break;
 
475
        case SCH_TODO_UNREG:
 
476
                css_sch_device_unregister(sch);
 
477
                break;
 
478
        }
 
479
        /* Release workqueue ref. */
 
480
        put_device(&sch->dev);
 
481
}
 
482
 
 
483
static struct idset *slow_subchannel_set;
 
484
static spinlock_t slow_subchannel_lock;
 
485
static wait_queue_head_t css_eval_wq;
 
486
static atomic_t css_eval_scheduled;
 
487
 
 
488
static int __init slow_subchannel_init(void)
 
489
{
 
490
        spin_lock_init(&slow_subchannel_lock);
 
491
        atomic_set(&css_eval_scheduled, 0);
 
492
        init_waitqueue_head(&css_eval_wq);
 
493
        slow_subchannel_set = idset_sch_new();
 
494
        if (!slow_subchannel_set) {
 
495
                CIO_MSG_EVENT(0, "could not allocate slow subchannel set\n");
 
496
                return -ENOMEM;
 
497
        }
 
498
        return 0;
 
499
}
 
500
 
 
501
static int slow_eval_known_fn(struct subchannel *sch, void *data)
 
502
{
 
503
        int eval;
 
504
        int rc;
 
505
 
 
506
        spin_lock_irq(&slow_subchannel_lock);
 
507
        eval = idset_sch_contains(slow_subchannel_set, sch->schid);
 
508
        idset_sch_del(slow_subchannel_set, sch->schid);
 
509
        spin_unlock_irq(&slow_subchannel_lock);
 
510
        if (eval) {
 
511
                rc = css_evaluate_known_subchannel(sch, 1);
 
512
                if (rc == -EAGAIN)
 
513
                        css_schedule_eval(sch->schid);
 
514
        }
 
515
        return 0;
 
516
}
 
517
 
 
518
static int slow_eval_unknown_fn(struct subchannel_id schid, void *data)
 
519
{
 
520
        int eval;
 
521
        int rc = 0;
 
522
 
 
523
        spin_lock_irq(&slow_subchannel_lock);
 
524
        eval = idset_sch_contains(slow_subchannel_set, schid);
 
525
        idset_sch_del(slow_subchannel_set, schid);
 
526
        spin_unlock_irq(&slow_subchannel_lock);
 
527
        if (eval) {
 
528
                rc = css_evaluate_new_subchannel(schid, 1);
 
529
                switch (rc) {
 
530
                case -EAGAIN:
 
531
                        css_schedule_eval(schid);
 
532
                        rc = 0;
 
533
                        break;
 
534
                case -ENXIO:
 
535
                case -ENOMEM:
 
536
                case -EIO:
 
537
                        /* These should abort looping */
 
538
                        break;
 
539
                default:
 
540
                        rc = 0;
 
541
                }
 
542
        }
 
543
        return rc;
 
544
}
 
545
 
 
546
static void css_slow_path_func(struct work_struct *unused)
 
547
{
 
548
        unsigned long flags;
 
549
 
 
550
        CIO_TRACE_EVENT(4, "slowpath");
 
551
        for_each_subchannel_staged(slow_eval_known_fn, slow_eval_unknown_fn,
 
552
                                   NULL);
 
553
        spin_lock_irqsave(&slow_subchannel_lock, flags);
 
554
        if (idset_is_empty(slow_subchannel_set)) {
 
555
                atomic_set(&css_eval_scheduled, 0);
 
556
                wake_up(&css_eval_wq);
 
557
        }
 
558
        spin_unlock_irqrestore(&slow_subchannel_lock, flags);
 
559
}
 
560
 
 
561
static DECLARE_WORK(slow_path_work, css_slow_path_func);
 
562
struct workqueue_struct *cio_work_q;
 
563
 
 
564
void css_schedule_eval(struct subchannel_id schid)
 
565
{
 
566
        unsigned long flags;
 
567
 
 
568
        spin_lock_irqsave(&slow_subchannel_lock, flags);
 
569
        idset_sch_add(slow_subchannel_set, schid);
 
570
        atomic_set(&css_eval_scheduled, 1);
 
571
        queue_work(cio_work_q, &slow_path_work);
 
572
        spin_unlock_irqrestore(&slow_subchannel_lock, flags);
 
573
}
 
574
 
 
575
void css_schedule_eval_all(void)
 
576
{
 
577
        unsigned long flags;
 
578
 
 
579
        spin_lock_irqsave(&slow_subchannel_lock, flags);
 
580
        idset_fill(slow_subchannel_set);
 
581
        atomic_set(&css_eval_scheduled, 1);
 
582
        queue_work(cio_work_q, &slow_path_work);
 
583
        spin_unlock_irqrestore(&slow_subchannel_lock, flags);
 
584
}
 
585
 
 
586
static int __unset_registered(struct device *dev, void *data)
 
587
{
 
588
        struct idset *set = data;
 
589
        struct subchannel *sch = to_subchannel(dev);
 
590
 
 
591
        idset_sch_del(set, sch->schid);
 
592
        return 0;
 
593
}
 
594
 
 
595
static void css_schedule_eval_all_unreg(void)
 
596
{
 
597
        unsigned long flags;
 
598
        struct idset *unreg_set;
 
599
 
 
600
        /* Find unregistered subchannels. */
 
601
        unreg_set = idset_sch_new();
 
602
        if (!unreg_set) {
 
603
                /* Fallback. */
 
604
                css_schedule_eval_all();
 
605
                return;
 
606
        }
 
607
        idset_fill(unreg_set);
 
608
        bus_for_each_dev(&css_bus_type, NULL, unreg_set, __unset_registered);
 
609
        /* Apply to slow_subchannel_set. */
 
610
        spin_lock_irqsave(&slow_subchannel_lock, flags);
 
611
        idset_add_set(slow_subchannel_set, unreg_set);
 
612
        atomic_set(&css_eval_scheduled, 1);
 
613
        queue_work(cio_work_q, &slow_path_work);
 
614
        spin_unlock_irqrestore(&slow_subchannel_lock, flags);
 
615
        idset_free(unreg_set);
 
616
}
 
617
 
 
618
void css_wait_for_slow_path(void)
 
619
{
 
620
        flush_workqueue(cio_work_q);
 
621
}
 
622
 
 
623
/* Schedule reprobing of all unregistered subchannels. */
 
624
void css_schedule_reprobe(void)
 
625
{
 
626
        css_schedule_eval_all_unreg();
 
627
}
 
628
EXPORT_SYMBOL_GPL(css_schedule_reprobe);
 
629
 
 
630
/*
 
631
 * Called from the machine check handler for subchannel report words.
 
632
 */
 
633
static void css_process_crw(struct crw *crw0, struct crw *crw1, int overflow)
 
634
{
 
635
        struct subchannel_id mchk_schid;
 
636
        struct subchannel *sch;
 
637
 
 
638
        if (overflow) {
 
639
                css_schedule_eval_all();
 
640
                return;
 
641
        }
 
642
        CIO_CRW_EVENT(2, "CRW0 reports slct=%d, oflw=%d, "
 
643
                      "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
 
644
                      crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc,
 
645
                      crw0->erc, crw0->rsid);
 
646
        if (crw1)
 
647
                CIO_CRW_EVENT(2, "CRW1 reports slct=%d, oflw=%d, "
 
648
                              "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
 
649
                              crw1->slct, crw1->oflw, crw1->chn, crw1->rsc,
 
650
                              crw1->anc, crw1->erc, crw1->rsid);
 
651
        init_subchannel_id(&mchk_schid);
 
652
        mchk_schid.sch_no = crw0->rsid;
 
653
        if (crw1)
 
654
                mchk_schid.ssid = (crw1->rsid >> 4) & 3;
 
655
 
 
656
        if (crw0->erc == CRW_ERC_PMOD) {
 
657
                sch = get_subchannel_by_schid(mchk_schid);
 
658
                if (sch) {
 
659
                        css_update_ssd_info(sch);
 
660
                        put_device(&sch->dev);
 
661
                }
 
662
        }
 
663
        /*
 
664
         * Since we are always presented with IPI in the CRW, we have to
 
665
         * use stsch() to find out if the subchannel in question has come
 
666
         * or gone.
 
667
         */
 
668
        css_evaluate_subchannel(mchk_schid, 0);
 
669
}
 
670
 
 
671
static void __init
 
672
css_generate_pgid(struct channel_subsystem *css, u32 tod_high)
 
673
{
 
674
        struct cpuid cpu_id;
 
675
 
 
676
        if (css_general_characteristics.mcss) {
 
677
                css->global_pgid.pgid_high.ext_cssid.version = 0x80;
 
678
                css->global_pgid.pgid_high.ext_cssid.cssid = css->cssid;
 
679
        } else {
 
680
#ifdef CONFIG_SMP
 
681
                css->global_pgid.pgid_high.cpu_addr = stap();
 
682
#else
 
683
                css->global_pgid.pgid_high.cpu_addr = 0;
 
684
#endif
 
685
        }
 
686
        get_cpu_id(&cpu_id);
 
687
        css->global_pgid.cpu_id = cpu_id.ident;
 
688
        css->global_pgid.cpu_model = cpu_id.machine;
 
689
        css->global_pgid.tod_high = tod_high;
 
690
 
 
691
}
 
692
 
 
693
static void
 
694
channel_subsystem_release(struct device *dev)
 
695
{
 
696
        struct channel_subsystem *css;
 
697
 
 
698
        css = to_css(dev);
 
699
        mutex_destroy(&css->mutex);
 
700
        if (css->pseudo_subchannel) {
 
701
                /* Implies that it has been generated but never registered. */
 
702
                css_subchannel_release(&css->pseudo_subchannel->dev);
 
703
                css->pseudo_subchannel = NULL;
 
704
        }
 
705
        kfree(css);
 
706
}
 
707
 
 
708
static ssize_t
 
709
css_cm_enable_show(struct device *dev, struct device_attribute *attr,
 
710
                   char *buf)
 
711
{
 
712
        struct channel_subsystem *css = to_css(dev);
 
713
        int ret;
 
714
 
 
715
        if (!css)
 
716
                return 0;
 
717
        mutex_lock(&css->mutex);
 
718
        ret = sprintf(buf, "%x\n", css->cm_enabled);
 
719
        mutex_unlock(&css->mutex);
 
720
        return ret;
 
721
}
 
722
 
 
723
static ssize_t
 
724
css_cm_enable_store(struct device *dev, struct device_attribute *attr,
 
725
                    const char *buf, size_t count)
 
726
{
 
727
        struct channel_subsystem *css = to_css(dev);
 
728
        int ret;
 
729
        unsigned long val;
 
730
 
 
731
        ret = strict_strtoul(buf, 16, &val);
 
732
        if (ret)
 
733
                return ret;
 
734
        mutex_lock(&css->mutex);
 
735
        switch (val) {
 
736
        case 0:
 
737
                ret = css->cm_enabled ? chsc_secm(css, 0) : 0;
 
738
                break;
 
739
        case 1:
 
740
                ret = css->cm_enabled ? 0 : chsc_secm(css, 1);
 
741
                break;
 
742
        default:
 
743
                ret = -EINVAL;
 
744
        }
 
745
        mutex_unlock(&css->mutex);
 
746
        return ret < 0 ? ret : count;
 
747
}
 
748
 
 
749
static DEVICE_ATTR(cm_enable, 0644, css_cm_enable_show, css_cm_enable_store);
 
750
 
 
751
static int __init setup_css(int nr)
 
752
{
 
753
        u32 tod_high;
 
754
        int ret;
 
755
        struct channel_subsystem *css;
 
756
 
 
757
        css = channel_subsystems[nr];
 
758
        memset(css, 0, sizeof(struct channel_subsystem));
 
759
        css->pseudo_subchannel =
 
760
                kzalloc(sizeof(*css->pseudo_subchannel), GFP_KERNEL);
 
761
        if (!css->pseudo_subchannel)
 
762
                return -ENOMEM;
 
763
        css->pseudo_subchannel->dev.parent = &css->device;
 
764
        css->pseudo_subchannel->dev.release = css_subchannel_release;
 
765
        dev_set_name(&css->pseudo_subchannel->dev, "defunct");
 
766
        mutex_init(&css->pseudo_subchannel->reg_mutex);
 
767
        ret = cio_create_sch_lock(css->pseudo_subchannel);
 
768
        if (ret) {
 
769
                kfree(css->pseudo_subchannel);
 
770
                return ret;
 
771
        }
 
772
        mutex_init(&css->mutex);
 
773
        css->valid = 1;
 
774
        css->cssid = nr;
 
775
        dev_set_name(&css->device, "css%x", nr);
 
776
        css->device.release = channel_subsystem_release;
 
777
        tod_high = (u32) (get_clock() >> 32);
 
778
        css_generate_pgid(css, tod_high);
 
779
        return 0;
 
780
}
 
781
 
 
782
static int css_reboot_event(struct notifier_block *this,
 
783
                            unsigned long event,
 
784
                            void *ptr)
 
785
{
 
786
        int ret, i;
 
787
 
 
788
        ret = NOTIFY_DONE;
 
789
        for (i = 0; i <= __MAX_CSSID; i++) {
 
790
                struct channel_subsystem *css;
 
791
 
 
792
                css = channel_subsystems[i];
 
793
                mutex_lock(&css->mutex);
 
794
                if (css->cm_enabled)
 
795
                        if (chsc_secm(css, 0))
 
796
                                ret = NOTIFY_BAD;
 
797
                mutex_unlock(&css->mutex);
 
798
        }
 
799
 
 
800
        return ret;
 
801
}
 
802
 
 
803
static struct notifier_block css_reboot_notifier = {
 
804
        .notifier_call = css_reboot_event,
 
805
};
 
806
 
 
807
/*
 
808
 * Since the css devices are neither on a bus nor have a class
 
809
 * nor have a special device type, we cannot stop/restart channel
 
810
 * path measurements via the normal suspend/resume callbacks, but have
 
811
 * to use notifiers.
 
812
 */
 
813
static int css_power_event(struct notifier_block *this, unsigned long event,
 
814
                           void *ptr)
 
815
{
 
816
        int ret, i;
 
817
 
 
818
        switch (event) {
 
819
        case PM_HIBERNATION_PREPARE:
 
820
        case PM_SUSPEND_PREPARE:
 
821
                ret = NOTIFY_DONE;
 
822
                for (i = 0; i <= __MAX_CSSID; i++) {
 
823
                        struct channel_subsystem *css;
 
824
 
 
825
                        css = channel_subsystems[i];
 
826
                        mutex_lock(&css->mutex);
 
827
                        if (!css->cm_enabled) {
 
828
                                mutex_unlock(&css->mutex);
 
829
                                continue;
 
830
                        }
 
831
                        ret = __chsc_do_secm(css, 0);
 
832
                        ret = notifier_from_errno(ret);
 
833
                        mutex_unlock(&css->mutex);
 
834
                }
 
835
                break;
 
836
        case PM_POST_HIBERNATION:
 
837
        case PM_POST_SUSPEND:
 
838
                ret = NOTIFY_DONE;
 
839
                for (i = 0; i <= __MAX_CSSID; i++) {
 
840
                        struct channel_subsystem *css;
 
841
 
 
842
                        css = channel_subsystems[i];
 
843
                        mutex_lock(&css->mutex);
 
844
                        if (!css->cm_enabled) {
 
845
                                mutex_unlock(&css->mutex);
 
846
                                continue;
 
847
                        }
 
848
                        ret = __chsc_do_secm(css, 1);
 
849
                        ret = notifier_from_errno(ret);
 
850
                        mutex_unlock(&css->mutex);
 
851
                }
 
852
                /* search for subchannels, which appeared during hibernation */
 
853
                css_schedule_reprobe();
 
854
                break;
 
855
        default:
 
856
                ret = NOTIFY_DONE;
 
857
        }
 
858
        return ret;
 
859
 
 
860
}
 
861
static struct notifier_block css_power_notifier = {
 
862
        .notifier_call = css_power_event,
 
863
};
 
864
 
 
865
/*
 
866
 * Now that the driver core is running, we can setup our channel subsystem.
 
867
 * The struct subchannel's are created during probing (except for the
 
868
 * static console subchannel).
 
869
 */
 
870
static int __init css_bus_init(void)
 
871
{
 
872
        int ret, i;
 
873
 
 
874
        ret = chsc_init();
 
875
        if (ret)
 
876
                return ret;
 
877
 
 
878
        chsc_determine_css_characteristics();
 
879
        /* Try to enable MSS. */
 
880
        ret = chsc_enable_facility(CHSC_SDA_OC_MSS);
 
881
        if (ret)
 
882
                max_ssid = 0;
 
883
        else /* Success. */
 
884
                max_ssid = __MAX_SSID;
 
885
 
 
886
        ret = slow_subchannel_init();
 
887
        if (ret)
 
888
                goto out;
 
889
 
 
890
        ret = crw_register_handler(CRW_RSC_SCH, css_process_crw);
 
891
        if (ret)
 
892
                goto out;
 
893
 
 
894
        if ((ret = bus_register(&css_bus_type)))
 
895
                goto out;
 
896
 
 
897
        /* Setup css structure. */
 
898
        for (i = 0; i <= __MAX_CSSID; i++) {
 
899
                struct channel_subsystem *css;
 
900
 
 
901
                css = kmalloc(sizeof(struct channel_subsystem), GFP_KERNEL);
 
902
                if (!css) {
 
903
                        ret = -ENOMEM;
 
904
                        goto out_unregister;
 
905
                }
 
906
                channel_subsystems[i] = css;
 
907
                ret = setup_css(i);
 
908
                if (ret) {
 
909
                        kfree(channel_subsystems[i]);
 
910
                        goto out_unregister;
 
911
                }
 
912
                ret = device_register(&css->device);
 
913
                if (ret) {
 
914
                        put_device(&css->device);
 
915
                        goto out_unregister;
 
916
                }
 
917
                if (css_chsc_characteristics.secm) {
 
918
                        ret = device_create_file(&css->device,
 
919
                                                 &dev_attr_cm_enable);
 
920
                        if (ret)
 
921
                                goto out_device;
 
922
                }
 
923
                ret = device_register(&css->pseudo_subchannel->dev);
 
924
                if (ret) {
 
925
                        put_device(&css->pseudo_subchannel->dev);
 
926
                        goto out_file;
 
927
                }
 
928
        }
 
929
        ret = register_reboot_notifier(&css_reboot_notifier);
 
930
        if (ret)
 
931
                goto out_unregister;
 
932
        ret = register_pm_notifier(&css_power_notifier);
 
933
        if (ret) {
 
934
                unregister_reboot_notifier(&css_reboot_notifier);
 
935
                goto out_unregister;
 
936
        }
 
937
        css_init_done = 1;
 
938
 
 
939
        /* Enable default isc for I/O subchannels. */
 
940
        isc_register(IO_SCH_ISC);
 
941
 
 
942
        return 0;
 
943
out_file:
 
944
        if (css_chsc_characteristics.secm)
 
945
                device_remove_file(&channel_subsystems[i]->device,
 
946
                                   &dev_attr_cm_enable);
 
947
out_device:
 
948
        device_unregister(&channel_subsystems[i]->device);
 
949
out_unregister:
 
950
        while (i > 0) {
 
951
                struct channel_subsystem *css;
 
952
 
 
953
                i--;
 
954
                css = channel_subsystems[i];
 
955
                device_unregister(&css->pseudo_subchannel->dev);
 
956
                css->pseudo_subchannel = NULL;
 
957
                if (css_chsc_characteristics.secm)
 
958
                        device_remove_file(&css->device,
 
959
                                           &dev_attr_cm_enable);
 
960
                device_unregister(&css->device);
 
961
        }
 
962
        bus_unregister(&css_bus_type);
 
963
out:
 
964
        crw_unregister_handler(CRW_RSC_SCH);
 
965
        idset_free(slow_subchannel_set);
 
966
        chsc_init_cleanup();
 
967
        pr_alert("The CSS device driver initialization failed with "
 
968
                 "errno=%d\n", ret);
 
969
        return ret;
 
970
}
 
971
 
 
972
static void __init css_bus_cleanup(void)
 
973
{
 
974
        struct channel_subsystem *css;
 
975
        int i;
 
976
 
 
977
        for (i = 0; i <= __MAX_CSSID; i++) {
 
978
                css = channel_subsystems[i];
 
979
                device_unregister(&css->pseudo_subchannel->dev);
 
980
                css->pseudo_subchannel = NULL;
 
981
                if (css_chsc_characteristics.secm)
 
982
                        device_remove_file(&css->device, &dev_attr_cm_enable);
 
983
                device_unregister(&css->device);
 
984
        }
 
985
        bus_unregister(&css_bus_type);
 
986
        crw_unregister_handler(CRW_RSC_SCH);
 
987
        idset_free(slow_subchannel_set);
 
988
        chsc_init_cleanup();
 
989
        isc_unregister(IO_SCH_ISC);
 
990
}
 
991
 
 
992
static int __init channel_subsystem_init(void)
 
993
{
 
994
        int ret;
 
995
 
 
996
        ret = css_bus_init();
 
997
        if (ret)
 
998
                return ret;
 
999
        cio_work_q = create_singlethread_workqueue("cio");
 
1000
        if (!cio_work_q) {
 
1001
                ret = -ENOMEM;
 
1002
                goto out_bus;
 
1003
        }
 
1004
        ret = io_subchannel_init();
 
1005
        if (ret)
 
1006
                goto out_wq;
 
1007
 
 
1008
        return ret;
 
1009
out_wq:
 
1010
        destroy_workqueue(cio_work_q);
 
1011
out_bus:
 
1012
        css_bus_cleanup();
 
1013
        return ret;
 
1014
}
 
1015
subsys_initcall(channel_subsystem_init);
 
1016
 
 
1017
static int css_settle(struct device_driver *drv, void *unused)
 
1018
{
 
1019
        struct css_driver *cssdrv = to_cssdriver(drv);
 
1020
 
 
1021
        if (cssdrv->settle)
 
1022
                return cssdrv->settle();
 
1023
        return 0;
 
1024
}
 
1025
 
 
1026
int css_complete_work(void)
 
1027
{
 
1028
        int ret;
 
1029
 
 
1030
        /* Wait for the evaluation of subchannels to finish. */
 
1031
        ret = wait_event_interruptible(css_eval_wq,
 
1032
                                       atomic_read(&css_eval_scheduled) == 0);
 
1033
        if (ret)
 
1034
                return -EINTR;
 
1035
        flush_workqueue(cio_work_q);
 
1036
        /* Wait for the subchannel type specific initialization to finish */
 
1037
        return bus_for_each_drv(&css_bus_type, NULL, NULL, css_settle);
 
1038
}
 
1039
 
 
1040
 
 
1041
/*
 
1042
 * Wait for the initialization of devices to finish, to make sure we are
 
1043
 * done with our setup if the search for the root device starts.
 
1044
 */
 
1045
static int __init channel_subsystem_init_sync(void)
 
1046
{
 
1047
        /* Start initial subchannel evaluation. */
 
1048
        css_schedule_eval_all();
 
1049
        css_complete_work();
 
1050
        return 0;
 
1051
}
 
1052
subsys_initcall_sync(channel_subsystem_init_sync);
 
1053
 
 
1054
void channel_subsystem_reinit(void)
 
1055
{
 
1056
        struct channel_path *chp;
 
1057
        struct chp_id chpid;
 
1058
 
 
1059
        chsc_enable_facility(CHSC_SDA_OC_MSS);
 
1060
        chp_id_for_each(&chpid) {
 
1061
                chp = chpid_to_chp(chpid);
 
1062
                if (!chp)
 
1063
                        continue;
 
1064
                chsc_determine_base_channel_path_desc(chpid, &chp->desc);
 
1065
        }
 
1066
}
 
1067
 
 
1068
#ifdef CONFIG_PROC_FS
 
1069
static ssize_t cio_settle_write(struct file *file, const char __user *buf,
 
1070
                                size_t count, loff_t *ppos)
 
1071
{
 
1072
        int ret;
 
1073
 
 
1074
        /* Handle pending CRW's. */
 
1075
        crw_wait_for_channel_report();
 
1076
        ret = css_complete_work();
 
1077
 
 
1078
        return ret ? ret : count;
 
1079
}
 
1080
 
 
1081
static const struct file_operations cio_settle_proc_fops = {
 
1082
        .open = nonseekable_open,
 
1083
        .write = cio_settle_write,
 
1084
        .llseek = no_llseek,
 
1085
};
 
1086
 
 
1087
static int __init cio_settle_init(void)
 
1088
{
 
1089
        struct proc_dir_entry *entry;
 
1090
 
 
1091
        entry = proc_create("cio_settle", S_IWUSR, NULL,
 
1092
                            &cio_settle_proc_fops);
 
1093
        if (!entry)
 
1094
                return -ENOMEM;
 
1095
        return 0;
 
1096
}
 
1097
device_initcall(cio_settle_init);
 
1098
#endif /*CONFIG_PROC_FS*/
 
1099
 
 
1100
int sch_is_pseudo_sch(struct subchannel *sch)
 
1101
{
 
1102
        return sch == to_css(sch->dev.parent)->pseudo_subchannel;
 
1103
}
 
1104
 
 
1105
static int css_bus_match(struct device *dev, struct device_driver *drv)
 
1106
{
 
1107
        struct subchannel *sch = to_subchannel(dev);
 
1108
        struct css_driver *driver = to_cssdriver(drv);
 
1109
        struct css_device_id *id;
 
1110
 
 
1111
        for (id = driver->subchannel_type; id->match_flags; id++) {
 
1112
                if (sch->st == id->type)
 
1113
                        return 1;
 
1114
        }
 
1115
 
 
1116
        return 0;
 
1117
}
 
1118
 
 
1119
static int css_probe(struct device *dev)
 
1120
{
 
1121
        struct subchannel *sch;
 
1122
        int ret;
 
1123
 
 
1124
        sch = to_subchannel(dev);
 
1125
        sch->driver = to_cssdriver(dev->driver);
 
1126
        ret = sch->driver->probe ? sch->driver->probe(sch) : 0;
 
1127
        if (ret)
 
1128
                sch->driver = NULL;
 
1129
        return ret;
 
1130
}
 
1131
 
 
1132
static int css_remove(struct device *dev)
 
1133
{
 
1134
        struct subchannel *sch;
 
1135
        int ret;
 
1136
 
 
1137
        sch = to_subchannel(dev);
 
1138
        ret = sch->driver->remove ? sch->driver->remove(sch) : 0;
 
1139
        sch->driver = NULL;
 
1140
        return ret;
 
1141
}
 
1142
 
 
1143
static void css_shutdown(struct device *dev)
 
1144
{
 
1145
        struct subchannel *sch;
 
1146
 
 
1147
        sch = to_subchannel(dev);
 
1148
        if (sch->driver && sch->driver->shutdown)
 
1149
                sch->driver->shutdown(sch);
 
1150
}
 
1151
 
 
1152
static int css_uevent(struct device *dev, struct kobj_uevent_env *env)
 
1153
{
 
1154
        struct subchannel *sch = to_subchannel(dev);
 
1155
        int ret;
 
1156
 
 
1157
        ret = add_uevent_var(env, "ST=%01X", sch->st);
 
1158
        if (ret)
 
1159
                return ret;
 
1160
        ret = add_uevent_var(env, "MODALIAS=css:t%01X", sch->st);
 
1161
        return ret;
 
1162
}
 
1163
 
 
1164
static int css_pm_prepare(struct device *dev)
 
1165
{
 
1166
        struct subchannel *sch = to_subchannel(dev);
 
1167
        struct css_driver *drv;
 
1168
 
 
1169
        if (mutex_is_locked(&sch->reg_mutex))
 
1170
                return -EAGAIN;
 
1171
        if (!sch->dev.driver)
 
1172
                return 0;
 
1173
        drv = to_cssdriver(sch->dev.driver);
 
1174
        /* Notify drivers that they may not register children. */
 
1175
        return drv->prepare ? drv->prepare(sch) : 0;
 
1176
}
 
1177
 
 
1178
static void css_pm_complete(struct device *dev)
 
1179
{
 
1180
        struct subchannel *sch = to_subchannel(dev);
 
1181
        struct css_driver *drv;
 
1182
 
 
1183
        if (!sch->dev.driver)
 
1184
                return;
 
1185
        drv = to_cssdriver(sch->dev.driver);
 
1186
        if (drv->complete)
 
1187
                drv->complete(sch);
 
1188
}
 
1189
 
 
1190
static int css_pm_freeze(struct device *dev)
 
1191
{
 
1192
        struct subchannel *sch = to_subchannel(dev);
 
1193
        struct css_driver *drv;
 
1194
 
 
1195
        if (!sch->dev.driver)
 
1196
                return 0;
 
1197
        drv = to_cssdriver(sch->dev.driver);
 
1198
        return drv->freeze ? drv->freeze(sch) : 0;
 
1199
}
 
1200
 
 
1201
static int css_pm_thaw(struct device *dev)
 
1202
{
 
1203
        struct subchannel *sch = to_subchannel(dev);
 
1204
        struct css_driver *drv;
 
1205
 
 
1206
        if (!sch->dev.driver)
 
1207
                return 0;
 
1208
        drv = to_cssdriver(sch->dev.driver);
 
1209
        return drv->thaw ? drv->thaw(sch) : 0;
 
1210
}
 
1211
 
 
1212
static int css_pm_restore(struct device *dev)
 
1213
{
 
1214
        struct subchannel *sch = to_subchannel(dev);
 
1215
        struct css_driver *drv;
 
1216
 
 
1217
        css_update_ssd_info(sch);
 
1218
        if (!sch->dev.driver)
 
1219
                return 0;
 
1220
        drv = to_cssdriver(sch->dev.driver);
 
1221
        return drv->restore ? drv->restore(sch) : 0;
 
1222
}
 
1223
 
 
1224
static const struct dev_pm_ops css_pm_ops = {
 
1225
        .prepare = css_pm_prepare,
 
1226
        .complete = css_pm_complete,
 
1227
        .freeze = css_pm_freeze,
 
1228
        .thaw = css_pm_thaw,
 
1229
        .restore = css_pm_restore,
 
1230
};
 
1231
 
 
1232
static struct bus_type css_bus_type = {
 
1233
        .name     = "css",
 
1234
        .match    = css_bus_match,
 
1235
        .probe    = css_probe,
 
1236
        .remove   = css_remove,
 
1237
        .shutdown = css_shutdown,
 
1238
        .uevent   = css_uevent,
 
1239
        .pm = &css_pm_ops,
 
1240
};
 
1241
 
 
1242
/**
 
1243
 * css_driver_register - register a css driver
 
1244
 * @cdrv: css driver to register
 
1245
 *
 
1246
 * This is mainly a wrapper around driver_register that sets name
 
1247
 * and bus_type in the embedded struct device_driver correctly.
 
1248
 */
 
1249
int css_driver_register(struct css_driver *cdrv)
 
1250
{
 
1251
        cdrv->drv.bus = &css_bus_type;
 
1252
        return driver_register(&cdrv->drv);
 
1253
}
 
1254
EXPORT_SYMBOL_GPL(css_driver_register);
 
1255
 
 
1256
/**
 
1257
 * css_driver_unregister - unregister a css driver
 
1258
 * @cdrv: css driver to unregister
 
1259
 *
 
1260
 * This is a wrapper around driver_unregister.
 
1261
 */
 
1262
void css_driver_unregister(struct css_driver *cdrv)
 
1263
{
 
1264
        driver_unregister(&cdrv->drv);
 
1265
}
 
1266
EXPORT_SYMBOL_GPL(css_driver_unregister);
 
1267
 
 
1268
MODULE_LICENSE("GPL");