projects / GitHub / LineageOS / android_kernel_samsung_universal7580.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
sg: add missing sg_init_table calls to zfcp
[GitHub/LineageOS/android_kernel_samsung_universal7580.git] / drivers / block / sunvdc.c
CommitLineData
667ef3c3
DM		 1/* sunvdc.c: Sun LDOM Virtual Disk Client.
2 *
3 * Copyright (C) 2007 David S. Miller <davem@davemloft.net>
4 */
5
6#include <linux/module.h>
7#include <linux/kernel.h>
8#include <linux/types.h>
9#include <linux/blkdev.h>
10#include <linux/hdreg.h>
11#include <linux/genhd.h>
12#include <linux/slab.h>
13#include <linux/spinlock.h>
14#include <linux/completion.h>
15#include <linux/delay.h>
16#include <linux/init.h>
17#include <linux/list.h>
18
19#include <asm/vio.h>
20#include <asm/ldc.h>
21
22#define DRV_MODULE_NAME "sunvdc"
23#define PFX DRV_MODULE_NAME ": "
24#define DRV_MODULE_VERSION "1.0"
25#define DRV_MODULE_RELDATE "June 25, 2007"
26
27static char version[] __devinitdata =
28 DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
29MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
30MODULE_DESCRIPTION("Sun LDOM virtual disk client driver");
31MODULE_LICENSE("GPL");
32MODULE_VERSION(DRV_MODULE_VERSION);
33
34#define VDC_TX_RING_SIZE 256
35
36#define WAITING_FOR_LINK_UP 0x01
37#define WAITING_FOR_TX_SPACE 0x02
38#define WAITING_FOR_GEN_CMD 0x04
39#define WAITING_FOR_ANY -1
40
41struct vdc_req_entry {
42 struct request *req;
43};
44
45struct vdc_port {
46 struct vio_driver_state vio;
47
667ef3c3
DM		 48 struct gendisk *disk;
49
50 struct vdc_completion *cmp;
51
52 u64 req_id;
53 u64 seq;
54 struct vdc_req_entry rq_arr[VDC_TX_RING_SIZE];
55
56 unsigned long ring_cookies;
57
58 u64 max_xfer_size;
59 u32 vdisk_block_size;
60
61 /* The server fills these in for us in the disk attribute
62 * ACK packet.
63 */
64 u64 operations;
65 u32 vdisk_size;
66 u8 vdisk_type;
667ef3c3
DM		 67
68 char disk_name[32];
69
70 struct vio_disk_geom geom;
71 struct vio_disk_vtoc label;
667ef3c3
DM		 72};
73
74static inline struct vdc_port *to_vdc_port(struct vio_driver_state *vio)
75{
76 return container_of(vio, struct vdc_port, vio);
77}
78
667ef3c3
DM		 79/* Ordered from largest major to lowest */
80static struct vio_version vdc_versions[] = {
81 { .major = 1, .minor = 0 },
82};
83
84#define VDCBLK_NAME "vdisk"
85static int vdc_major;
86#define PARTITION_SHIFT 3
87
88static inline u32 vdc_tx_dring_avail(struct vio_dring_state *dr)
89{
90 return vio_dring_avail(dr, VDC_TX_RING_SIZE);
91}
92
93static int vdc_getgeo(struct block_device *bdev, struct hd_geometry *geo)
94{
95 struct gendisk *disk = bdev->bd_disk;
96 struct vdc_port *port = disk->private_data;
97
98 geo->heads = (u8) port->geom.num_hd;
99 geo->sectors = (u8) port->geom.num_sec;
100 geo->cylinders = port->geom.num_cyl;
101
102 return 0;
103}
104
105static struct block_device_operations vdc_fops = {
106 .owner = THIS_MODULE,
107 .getgeo = vdc_getgeo,
108};
109
110static void vdc_finish(struct vio_driver_state *vio, int err, int waiting_for)
111{
112 if (vio->cmp &&
113 (waiting_for == -1 ||
114 vio->cmp->waiting_for == waiting_for)) {
115 vio->cmp->err = err;
116 complete(&vio->cmp->com);
117 vio->cmp = NULL;
118 }
119}
120
121static void vdc_handshake_complete(struct vio_driver_state *vio)
122{
123 vdc_finish(vio, 0, WAITING_FOR_LINK_UP);
124}
125
126static int vdc_handle_unknown(struct vdc_port *port, void *arg)
127{
128 struct vio_msg_tag *pkt = arg;
129
130 printk(KERN_ERR PFX "Received unknown msg [%02x:%02x:%04x:%08x]\n",
131 pkt->type, pkt->stype, pkt->stype_env, pkt->sid);
132 printk(KERN_ERR PFX "Resetting connection.\n");
133
134 ldc_disconnect(port->vio.lp);
135
136 return -ECONNRESET;
137}
138
139static int vdc_send_attr(struct vio_driver_state *vio)
140{
141 struct vdc_port *port = to_vdc_port(vio);
142 struct vio_disk_attr_info pkt;
143
144 memset(&pkt, 0, sizeof(pkt));
145
146 pkt.tag.type = VIO_TYPE_CTRL;
147 pkt.tag.stype = VIO_SUBTYPE_INFO;
148 pkt.tag.stype_env = VIO_ATTR_INFO;
149 pkt.tag.sid = vio_send_sid(vio);
150
151 pkt.xfer_mode = VIO_DRING_MODE;
152 pkt.vdisk_block_size = port->vdisk_block_size;
153 pkt.max_xfer_size = port->max_xfer_size;
154
155 viodbg(HS, "SEND ATTR xfer_mode[0x%x] blksz[%u] max_xfer[%lu]\n",
156 pkt.xfer_mode, pkt.vdisk_block_size, pkt.max_xfer_size);
157
158 return vio_ldc_send(&port->vio, &pkt, sizeof(pkt));
159}
160
161static int vdc_handle_attr(struct vio_driver_state *vio, void *arg)
162{
163 struct vdc_port *port = to_vdc_port(vio);
164 struct vio_disk_attr_info *pkt = arg;
165
166 viodbg(HS, "GOT ATTR stype[0x%x] ops[%lx] disk_size[%lu] disk_type[%x] "
167 "xfer_mode[0x%x] blksz[%u] max_xfer[%lu]\n",
168 pkt->tag.stype, pkt->operations,
169 pkt->vdisk_size, pkt->vdisk_type,
170 pkt->xfer_mode, pkt->vdisk_block_size,
171 pkt->max_xfer_size);
172
173 if (pkt->tag.stype == VIO_SUBTYPE_ACK) {
174 switch (pkt->vdisk_type) {
175 case VD_DISK_TYPE_DISK:
176 case VD_DISK_TYPE_SLICE:
177 break;
178
179 default:
180 printk(KERN_ERR PFX "%s: Bogus vdisk_type 0x%x\n",
181 vio->name, pkt->vdisk_type);
182 return -ECONNRESET;
183 }
184
185 if (pkt->vdisk_block_size > port->vdisk_block_size) {
186 printk(KERN_ERR PFX "%s: BLOCK size increased "
187 "%u --> %u\n",
188 vio->name,
189 port->vdisk_block_size, pkt->vdisk_block_size);
190 return -ECONNRESET;
191 }
192
193 port->operations = pkt->operations;
194 port->vdisk_size = pkt->vdisk_size;
195 port->vdisk_type = pkt->vdisk_type;
196 if (pkt->max_xfer_size < port->max_xfer_size)
197 port->max_xfer_size = pkt->max_xfer_size;
198 port->vdisk_block_size = pkt->vdisk_block_size;
199 return 0;
200 } else {
201 printk(KERN_ERR PFX "%s: Attribute NACK\n", vio->name);
202
203 return -ECONNRESET;
204 }
205}
206
207static void vdc_end_special(struct vdc_port *port, struct vio_disk_desc *desc)
208{
209 int err = desc->status;
210
211 vdc_finish(&port->vio, -err, WAITING_FOR_GEN_CMD);
212}
213
214static void vdc_end_request(struct request *req, int uptodate, int num_sectors)
215{
216 if (end_that_request_first(req, uptodate, num_sectors))
217 return;
218 add_disk_randomness(req->rq_disk);
219 end_that_request_last(req, uptodate);
220}
221
222static void vdc_end_one(struct vdc_port *port, struct vio_dring_state *dr,
223 unsigned int index)
224{
225 struct vio_disk_desc *desc = vio_dring_entry(dr, index);
226 struct vdc_req_entry *rqe = &port->rq_arr[index];
227 struct request *req;
228
229 if (unlikely(desc->hdr.state != VIO_DESC_DONE))
230 return;
231
232 ldc_unmap(port->vio.lp, desc->cookies, desc->ncookies);
233 desc->hdr.state = VIO_DESC_FREE;
234 dr->cons = (index + 1) & (VDC_TX_RING_SIZE - 1);
235
236 req = rqe->req;
237 if (req == NULL) {
238 vdc_end_special(port, desc);
239 return;
240 }
241
242 rqe->req = NULL;
243
244 vdc_end_request(req, !desc->status, desc->size >> 9);
245
246 if (blk_queue_stopped(port->disk->queue))
247 blk_start_queue(port->disk->queue);
248}
249
250static int vdc_ack(struct vdc_port *port, void *msgbuf)
251{
252 struct vio_dring_state *dr = &port->vio.drings[VIO_DRIVER_TX_RING];
253 struct vio_dring_data *pkt = msgbuf;
254
255 if (unlikely(pkt->dring_ident != dr->ident ||
256 pkt->start_idx != pkt->end_idx ||
257 pkt->start_idx >= VDC_TX_RING_SIZE))
258 return 0;
259
260 vdc_end_one(port, dr, pkt->start_idx);
261
262 return 0;
263}
264
265static int vdc_nack(struct vdc_port *port, void *msgbuf)
266{
267 /* XXX Implement me XXX */
268 return 0;
269}
270
271static void vdc_event(void *arg, int event)
272{
273 struct vdc_port *port = arg;
274 struct vio_driver_state *vio = &port->vio;
275 unsigned long flags;
276 int err;
277
278 spin_lock_irqsave(&vio->lock, flags);
279
280 if (unlikely(event == LDC_EVENT_RESET ||
281 event == LDC_EVENT_UP)) {
282 vio_link_state_change(vio, event);
283 spin_unlock_irqrestore(&vio->lock, flags);
284 return;
285 }
286
287 if (unlikely(event != LDC_EVENT_DATA_READY)) {
288 printk(KERN_WARNING PFX "Unexpected LDC event %d\n", event);
289 spin_unlock_irqrestore(&vio->lock, flags);
290 return;
291 }
292
293 err = 0;
294 while (1) {
295 union {
296 struct vio_msg_tag tag;
297 u64 raw[8];
298 } msgbuf;
299
300 err = ldc_read(vio->lp, &msgbuf, sizeof(msgbuf));
301 if (unlikely(err < 0)) {
302 if (err == -ECONNRESET)
303 vio_conn_reset(vio);
304 break;
305 }
306 if (err == 0)
307 break;
308 viodbg(DATA, "TAG [%02x:%02x:%04x:%08x]\n",
309 msgbuf.tag.type,
310 msgbuf.tag.stype,
311 msgbuf.tag.stype_env,
312 msgbuf.tag.sid);
313 err = vio_validate_sid(vio, &msgbuf.tag);
314 if (err < 0)
315 break;
316
317 if (likely(msgbuf.tag.type == VIO_TYPE_DATA)) {
318 if (msgbuf.tag.stype == VIO_SUBTYPE_ACK)
319 err = vdc_ack(port, &msgbuf);
320 else if (msgbuf.tag.stype == VIO_SUBTYPE_NACK)
321 err = vdc_nack(port, &msgbuf);
322 else
323 err = vdc_handle_unknown(port, &msgbuf);
324 } else if (msgbuf.tag.type == VIO_TYPE_CTRL) {
325 err = vio_control_pkt_engine(vio, &msgbuf);
326 } else {
327 err = vdc_handle_unknown(port, &msgbuf);
328 }
329 if (err < 0)
330 break;
331 }
332 if (err < 0)
333 vdc_finish(&port->vio, err, WAITING_FOR_ANY);
334 spin_unlock_irqrestore(&vio->lock, flags);
335}
336
337static int __vdc_tx_trigger(struct vdc_port *port)
338{
339 struct vio_dring_state *dr = &port->vio.drings[VIO_DRIVER_TX_RING];
340 struct vio_dring_data hdr = {
341 .tag = {
342 .type = VIO_TYPE_DATA,
343 .stype = VIO_SUBTYPE_INFO,
344 .stype_env = VIO_DRING_DATA,
345 .sid = vio_send_sid(&port->vio),
346 },
347 .dring_ident = dr->ident,
348 .start_idx = dr->prod,
349 .end_idx = dr->prod,
350 };
351 int err, delay;
352
353 hdr.seq = dr->snd_nxt;
354 delay = 1;
355 do {
356 err = vio_ldc_send(&port->vio, &hdr, sizeof(hdr));
357 if (err > 0) {
358 dr->snd_nxt++;
359 break;
360 }
361 udelay(delay);
362 if ((delay <<= 1) > 128)
363 delay = 128;
364 } while (err == -EAGAIN);
365
366 return err;
367}
368
369static int __send_request(struct request *req)
370{
371 struct vdc_port *port = req->rq_disk->private_data;
372 struct vio_dring_state *dr = &port->vio.drings[VIO_DRIVER_TX_RING];
373 struct scatterlist sg[port->ring_cookies];
374 struct vdc_req_entry *rqe;
375 struct vio_disk_desc *desc;
376 unsigned int map_perm;
377 int nsg, err, i;
378 u64 len;
379 u8 op;
380
381 map_perm = LDC_MAP_SHADOW | LDC_MAP_DIRECT | LDC_MAP_IO;
382
383 if (rq_data_dir(req) == READ) {
384 map_perm |= LDC_MAP_W;
385 op = VD_OP_BREAD;
386 } else {
387 map_perm |= LDC_MAP_R;
388 op = VD_OP_BWRITE;
389 }
390
45711f1a 391 sg_init_table(sg, port->ring_cookies);
667ef3c3
DM		 392 nsg = blk_rq_map_sg(req->q, req, sg);
393
394 len = 0;
395 for (i = 0; i < nsg; i++)
396 len += sg[i].length;
397
398 if (unlikely(vdc_tx_dring_avail(dr) < 1)) {
399 blk_stop_queue(port->disk->queue);
400 err = -ENOMEM;
401 goto out;
402 }
403
404 desc = vio_dring_cur(dr);
405
406 err = ldc_map_sg(port->vio.lp, sg, nsg,
407 desc->cookies, port->ring_cookies,
408 map_perm);
409 if (err < 0) {
410 printk(KERN_ERR PFX "ldc_map_sg() failure, err=%d.\n", err);
411 return err;
412 }
413
414 rqe = &port->rq_arr[dr->prod];
415 rqe->req = req;
416
417 desc->hdr.ack = VIO_ACK_ENABLE;
418 desc->req_id = port->req_id;
419 desc->operation = op;
420 if (port->vdisk_type == VD_DISK_TYPE_DISK) {
1bd4b280 421 desc->slice = 0xff;
667ef3c3
DM		 422 } else {
423 desc->slice = 0;
424 }
425 desc->status = ~0;
426 desc->offset = (req->sector << 9) / port->vdisk_block_size;
427 desc->size = len;
428 desc->ncookies = err;
429
430 /* This has to be a non-SMP write barrier because we are writing
431 * to memory which is shared with the peer LDOM.
432 */
433 wmb();
434 desc->hdr.state = VIO_DESC_READY;
435
436 err = __vdc_tx_trigger(port);
437 if (err < 0) {
438 printk(KERN_ERR PFX "vdc_tx_trigger() failure, err=%d\n", err);
439 } else {
440 port->req_id++;
441 dr->prod = (dr->prod + 1) & (VDC_TX_RING_SIZE - 1);
442 }
443out:
444
445 return err;
446}
447
165125e1 448static void do_vdc_request(struct request_queue *q)
667ef3c3
DM		 449{
450 while (1) {
451 struct request *req = elv_next_request(q);
452
453 if (!req)
454 break;
455
456 blkdev_dequeue_request(req);
457 if (__send_request(req) < 0)
458 vdc_end_request(req, 0, req->hard_nr_sectors);
459 }
460}
461
462static int generic_request(struct vdc_port *port, u8 op, void *buf, int len)
463{
464 struct vio_dring_state *dr;
465 struct vio_completion comp;
466 struct vio_disk_desc *desc;
467 unsigned int map_perm;
468 unsigned long flags;
469 int op_len, err;
470 void *req_buf;
471
472 if (!(((u64)1 << ((u64)op - 1)) & port->operations))
473 return -EOPNOTSUPP;
474
475 switch (op) {
476 case VD_OP_BREAD:
477 case VD_OP_BWRITE:
478 default:
479 return -EINVAL;
480
481 case VD_OP_FLUSH:
482 op_len = 0;
483 map_perm = 0;
484 break;
485
486 case VD_OP_GET_WCE:
487 op_len = sizeof(u32);
488 map_perm = LDC_MAP_W;
489 break;
490
491 case VD_OP_SET_WCE:
492 op_len = sizeof(u32);
493 map_perm = LDC_MAP_R;
494 break;
495
496 case VD_OP_GET_VTOC:
497 op_len = sizeof(struct vio_disk_vtoc);
498 map_perm = LDC_MAP_W;
499 break;
500
501 case VD_OP_SET_VTOC:
502 op_len = sizeof(struct vio_disk_vtoc);
503 map_perm = LDC_MAP_R;
504 break;
505
506 case VD_OP_GET_DISKGEOM:
507 op_len = sizeof(struct vio_disk_geom);
508 map_perm = LDC_MAP_W;
509 break;
510
511 case VD_OP_SET_DISKGEOM:
512 op_len = sizeof(struct vio_disk_geom);
513 map_perm = LDC_MAP_R;
514 break;
515
516 case VD_OP_SCSICMD:
517 op_len = 16;
518 map_perm = LDC_MAP_RW;
519 break;
520
521 case VD_OP_GET_DEVID:
522 op_len = sizeof(struct vio_disk_devid);
523 map_perm = LDC_MAP_W;
524 break;
525
526 case VD_OP_GET_EFI:
527 case VD_OP_SET_EFI:
528 return -EOPNOTSUPP;
529 break;
530 };
531
532 map_perm |= LDC_MAP_SHADOW | LDC_MAP_DIRECT | LDC_MAP_IO;
533
534 op_len = (op_len + 7) & ~7;
535 req_buf = kzalloc(op_len, GFP_KERNEL);
536 if (!req_buf)
537 return -ENOMEM;
538
539 if (len > op_len)
540 len = op_len;
541
542 if (map_perm & LDC_MAP_R)
543 memcpy(req_buf, buf, len);
544
545 spin_lock_irqsave(&port->vio.lock, flags);
546
547 dr = &port->vio.drings[VIO_DRIVER_TX_RING];
548
549 /* XXX If we want to use this code generically we have to
550 * XXX handle TX ring exhaustion etc.
551 */
552 desc = vio_dring_cur(dr);
553
554 err = ldc_map_single(port->vio.lp, req_buf, op_len,
555 desc->cookies, port->ring_cookies,
556 map_perm);
557 if (err < 0) {
558 spin_unlock_irqrestore(&port->vio.lock, flags);
559 kfree(req_buf);
560 return err;
561 }
562
563 init_completion(&comp.com);
564 comp.waiting_for = WAITING_FOR_GEN_CMD;
565 port->vio.cmp = &comp;
566
567 desc->hdr.ack = VIO_ACK_ENABLE;
568 desc->req_id = port->req_id;
569 desc->operation = op;
570 desc->slice = 0;
571 desc->status = ~0;
572 desc->offset = 0;
573 desc->size = op_len;
574 desc->ncookies = err;
575
576 /* This has to be a non-SMP write barrier because we are writing
577 * to memory which is shared with the peer LDOM.
578 */
579 wmb();
580 desc->hdr.state = VIO_DESC_READY;
581
582 err = __vdc_tx_trigger(port);
583 if (err >= 0) {
584 port->req_id++;
585 dr->prod = (dr->prod + 1) & (VDC_TX_RING_SIZE - 1);
586 spin_unlock_irqrestore(&port->vio.lock, flags);
587
588 wait_for_completion(&comp.com);
589 err = comp.err;
590 } else {
591 port->vio.cmp = NULL;
592 spin_unlock_irqrestore(&port->vio.lock, flags);
593 }
594
595 if (map_perm & LDC_MAP_W)
596 memcpy(buf, req_buf, len);
597
598 kfree(req_buf);
599
600 return err;
601}
602
603static int __devinit vdc_alloc_tx_ring(struct vdc_port *port)
604{
605 struct vio_dring_state *dr = &port->vio.drings[VIO_DRIVER_TX_RING];
606 unsigned long len, entry_size;
607 int ncookies;
608 void *dring;
609
610 entry_size = sizeof(struct vio_disk_desc) +
611 (sizeof(struct ldc_trans_cookie) * port->ring_cookies);
612 len = (VDC_TX_RING_SIZE * entry_size);
613
614 ncookies = VIO_MAX_RING_COOKIES;
615 dring = ldc_alloc_exp_dring(port->vio.lp, len,
616 dr->cookies, &ncookies,
617 (LDC_MAP_SHADOW |
618 LDC_MAP_DIRECT |
619 LDC_MAP_RW));
620 if (IS_ERR(dring))
621 return PTR_ERR(dring);
622
623 dr->base = dring;
624 dr->entry_size = entry_size;
625 dr->num_entries = VDC_TX_RING_SIZE;
626 dr->prod = dr->cons = 0;
627 dr->pending = VDC_TX_RING_SIZE;
628 dr->ncookies = ncookies;
629
630 return 0;
631}
632
633static void vdc_free_tx_ring(struct vdc_port *port)
634{
635 struct vio_dring_state *dr = &port->vio.drings[VIO_DRIVER_TX_RING];
636
637 if (dr->base) {
638 ldc_free_exp_dring(port->vio.lp, dr->base,
639 (dr->entry_size * dr->num_entries),
640 dr->cookies, dr->ncookies);
641 dr->base = NULL;
642 dr->entry_size = 0;
643 dr->num_entries = 0;
644 dr->pending = 0;
645 dr->ncookies = 0;
646 }
647}
648
649static int probe_disk(struct vdc_port *port)
650{
651 struct vio_completion comp;
652 struct request_queue *q;
653 struct gendisk *g;
654 int err;
655
656 init_completion(&comp.com);
657 comp.err = 0;
658 comp.waiting_for = WAITING_FOR_LINK_UP;
659 port->vio.cmp = &comp;
660
661 vio_port_up(&port->vio);
662
663 wait_for_completion(&comp.com);
664 if (comp.err)
665 return comp.err;
666
667 err = generic_request(port, VD_OP_GET_VTOC,
668 &port->label, sizeof(port->label));
669 if (err < 0) {
670 printk(KERN_ERR PFX "VD_OP_GET_VTOC returns error %d\n", err);
671 return err;
672 }
673
674 err = generic_request(port, VD_OP_GET_DISKGEOM,
675 &port->geom, sizeof(port->geom));
676 if (err < 0) {
677 printk(KERN_ERR PFX "VD_OP_GET_DISKGEOM returns "
678 "error %d\n", err);
679 return err;
680 }
681
682 port->vdisk_size = ((u64)port->geom.num_cyl *
683 (u64)port->geom.num_hd *
684 (u64)port->geom.num_sec);
685
686 q = blk_init_queue(do_vdc_request, &port->vio.lock);
687 if (!q) {
688 printk(KERN_ERR PFX "%s: Could not allocate queue.\n",
689 port->vio.name);
690 return -ENOMEM;
691 }
692 g = alloc_disk(1 << PARTITION_SHIFT);
693 if (!g) {
694 printk(KERN_ERR PFX "%s: Could not allocate gendisk.\n",
695 port->vio.name);
696 blk_cleanup_queue(q);
697 return -ENOMEM;
698 }
699
700 port->disk = g;
701
702 blk_queue_max_hw_segments(q, port->ring_cookies);
703 blk_queue_max_phys_segments(q, port->ring_cookies);
704 blk_queue_max_sectors(q, port->max_xfer_size);
705 g->major = vdc_major;
91ba3c21 706 g->first_minor = port->vio.vdev->dev_no << PARTITION_SHIFT;
667ef3c3
DM		 707 strcpy(g->disk_name, port->disk_name);
708
709 g->fops = &vdc_fops;
710 g->queue = q;
711 g->private_data = port;
712 g->driverfs_dev = &port->vio.vdev->dev;
713
714 set_capacity(g, port->vdisk_size);
715
716 printk(KERN_INFO PFX "%s: %u sectors (%u MB)\n",
717 g->disk_name,
718 port->vdisk_size, (port->vdisk_size >> (20 - 9)));
719
720 add_disk(g);
721
722 return 0;
723}
724
725static struct ldc_channel_config vdc_ldc_cfg = {
726 .event = vdc_event,
727 .mtu = 64,
728 .mode = LDC_MODE_UNRELIABLE,
729};
730
731static struct vio_driver_ops vdc_vio_ops = {
732 .send_attr = vdc_send_attr,
733 .handle_attr = vdc_handle_attr,
734 .handshake_complete = vdc_handshake_complete,
735};
736
80dc35df
DM		 737static void print_version(void)
738{
739 static int version_printed;
740
741 if (version_printed++ == 0)
742 printk(KERN_INFO "%s", version);
743}
744
667ef3c3
DM		 745static int __devinit vdc_port_probe(struct vio_dev *vdev,
746 const struct vio_device_id *id)
747{
43fdf274 748 struct mdesc_handle *hp;
667ef3c3 749 struct vdc_port *port;
667ef3c3
DM		 750 int err;
751
80dc35df 752 print_version();
667ef3c3 753
43fdf274 754 hp = mdesc_grab();
667ef3c3 755
43fdf274 756 err = -ENODEV;
91ba3c21
DM		 757 if ((vdev->dev_no << PARTITION_SHIFT) & ~(u64)MINORMASK) {
758 printk(KERN_ERR PFX "Port id [%lu] too large.\n",
759 vdev->dev_no);
43fdf274 760 goto err_out_release_mdesc;
667ef3c3
DM		 761 }
762
763 port = kzalloc(sizeof(*port), GFP_KERNEL);
43fdf274 764 err = -ENOMEM;
667ef3c3
DM		 765 if (!port) {
766 printk(KERN_ERR PFX "Cannot allocate vdc_port.\n");
43fdf274 767 goto err_out_release_mdesc;
667ef3c3
DM		 768 }
769
91ba3c21 770 if (vdev->dev_no >= 26)
667ef3c3
DM		 771 snprintf(port->disk_name, sizeof(port->disk_name),
772 VDCBLK_NAME "%c%c",
91ba3c21
DM		 773 'a' + ((int)vdev->dev_no / 26) - 1,
774 'a' + ((int)vdev->dev_no % 26));
667ef3c3
DM		 775 else
776 snprintf(port->disk_name, sizeof(port->disk_name),
91ba3c21 777 VDCBLK_NAME "%c", 'a' + ((int)vdev->dev_no % 26));
667ef3c3 778
43fdf274 779 err = vio_driver_init(&port->vio, vdev, VDEV_DISK,
667ef3c3
DM		 780 vdc_versions, ARRAY_SIZE(vdc_versions),
781 &vdc_vio_ops, port->disk_name);
782 if (err)
783 goto err_out_free_port;
784
785 port->vdisk_block_size = 512;
786 port->max_xfer_size = ((128 * 1024) / port->vdisk_block_size);
787 port->ring_cookies = ((port->max_xfer_size *
788 port->vdisk_block_size) / PAGE_SIZE) + 2;
789
790 err = vio_ldc_alloc(&port->vio, &vdc_ldc_cfg, port);
791 if (err)
792 goto err_out_free_port;
793
794 err = vdc_alloc_tx_ring(port);
795 if (err)
796 goto err_out_free_ldc;
797
798 err = probe_disk(port);
799 if (err)
800 goto err_out_free_tx_ring;
801
667ef3c3
DM		 802 dev_set_drvdata(&vdev->dev, port);
803
43fdf274
DM		 804 mdesc_release(hp);
805
667ef3c3
DM		 806 return 0;
807
808err_out_free_tx_ring:
809 vdc_free_tx_ring(port);
810
811err_out_free_ldc:
812 vio_ldc_free(&port->vio);
813
814err_out_free_port:
815 kfree(port);
816
43fdf274
DM		 817err_out_release_mdesc:
818 mdesc_release(hp);
667ef3c3
DM		 819 return err;
820}
821
822static int vdc_port_remove(struct vio_dev *vdev)
823{
824 struct vdc_port *port = dev_get_drvdata(&vdev->dev);
825
826 if (port) {
827 del_timer_sync(&port->vio.timer);
828
829 vdc_free_tx_ring(port);
830 vio_ldc_free(&port->vio);
831
832 dev_set_drvdata(&vdev->dev, NULL);
833
834 kfree(port);
835 }
836 return 0;
837}
838
839static struct vio_device_id vdc_port_match[] = {
840 {
841 .type = "vdc-port",
842 },
843 {},
844};
da68e081 845MODULE_DEVICE_TABLE(vio, vdc_port_match);
667ef3c3
DM		 846
847static struct vio_driver vdc_port_driver = {
848 .id_table = vdc_port_match,
849 .probe = vdc_port_probe,
850 .remove = vdc_port_remove,
851 .driver = {
852 .name = "vdc_port",
853 .owner = THIS_MODULE,
854 }
855};
856
667ef3c3
DM		 857static int __init vdc_init(void)
858{
859 int err;
860
861 err = register_blkdev(0, VDCBLK_NAME);
862 if (err < 0)
863 goto out_err;
864
865 vdc_major = err;
667ef3c3
DM		 866
867 err = vio_register_driver(&vdc_port_driver);
868 if (err)
80dc35df 869 goto out_unregister_blkdev;
667ef3c3
DM		 870
871 return 0;
872
667ef3c3
DM		 873out_unregister_blkdev:
874 unregister_blkdev(vdc_major, VDCBLK_NAME);
875 vdc_major = 0;
876
877out_err:
878 return err;
879}
880
881static void __exit vdc_exit(void)
882{
883 vio_unregister_driver(&vdc_port_driver);
667ef3c3
DM		 884 unregister_blkdev(vdc_major, VDCBLK_NAME);
885}
886
887module_init(vdc_init);
888module_exit(vdc_exit);