?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: unisys: fix CamelCase members of virtpci_dev
[linux-2.6/btrfs-unstable.git] / drivers / staging / unisys / virtpci / virtpci.c
blob52ec69f06b921a6d1a32de380095922fadcc1c74
1 /* virtpci.c
2 *
3 * Copyright (C) 2010 - 2013 UNISYS CORPORATION
4 * All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or (at
9 * your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
14 * NON INFRINGEMENT. See the GNU General Public License for more
15 * details.
16 */
17
18 #define EXPORT_SYMTAB
19
20 #include <linux/kernel.h>
21 #ifdef CONFIG_MODVERSIONS
22 #include <config/modversions.h>
23 #endif
24 #include "uniklog.h"
25 #include "diagnostics/appos_subsystems.h"
26 #include "uisutils.h"
27 #include "vbuschannel.h"
28 #include "vbushelper.h"
29 #include <linux/types.h>
30 #include <linux/io.h>
31 #include <linux/uuid.h>
32 #include <linux/module.h>
33 #include <linux/init.h>
34 #include <linux/pci.h>
35 #include <linux/device.h>
36 #include <linux/list.h>
37 #include <linux/slab.h>
38 #include <linux/mod_devicetable.h>
39 #include <linux/if_ether.h>
40 #include <linux/version.h>
41 #include <linux/debugfs.h>
42 #include "version.h"
43 #include "guestlinuxdebug.h"
44 #include "timskmod.h"
45
46 struct driver_private {
47 struct kobject kobj;
48 struct klist klist_devices;
49 struct klist_node knode_bus;
50 struct module_kobject *mkobj;
51 struct device_driver *driver;
52 };
53 #define to_driver(obj) container_of(obj, struct driver_private, kobj)
54
55 /* bus_id went away in 2.6.30 - the size was 20 bytes, so we'll define
56 * it ourselves, and a macro to make getting the field a bit simpler.
57 */
58 #ifndef BUS_ID_SIZE
59 #define BUS_ID_SIZE 20
60 #endif
61
62 #define BUS_ID(x) dev_name(x)
63
64 /* MAX_BUF = 4 busses x ( 32 devices/bus + 1 busline) x 80 characters
65 * = 10,560 bytes ~ 2^14 = 16,384 bytes
66 */
67 #define MAX_BUF 16384
68
69 #include "virtpci.h"
70
71 /* this is shorter than using __FILE__ (full path name) in
72 * debug/info/error messages
73 */
74 #define CURRENT_FILE_PC VIRT_PCI_PC_virtpci_c
75 #define __MYFILE__ "virtpci.c"
76
77 #define VIRTPCI_VERSION "01.00"
78
79 /*****************************************************/
80 /* Forward declarations */
81 /*****************************************************/
82
83 static int delete_vbus_device(struct device *vbus, void *data);
84 static int match_busid(struct device *dev, void *data);
85 static void virtpci_bus_release(struct device *dev);
86 static void virtpci_device_release(struct device *dev);
87 static int virtpci_device_add(struct device *parentbus, int devtype,
88 struct add_virt_guestpart *addparams,
89 struct scsi_adap_info *scsi,
90 struct net_adap_info *net);
91 static int virtpci_device_del(struct device *parentbus, int devtype,
92 struct vhba_wwnn *wwnn, unsigned char macaddr[]);
93 static int virtpci_device_serverdown(struct device *parentbus, int devtype,
94 struct vhba_wwnn *wwnn,
95 unsigned char macaddr[]);
96 static int virtpci_device_serverup(struct device *parentbus, int devtype,
97 struct vhba_wwnn *wwnn,
98 unsigned char macaddr[]);
99 static ssize_t virtpci_driver_attr_show(struct kobject *kobj,
100 struct attribute *attr, char *buf);
101 static ssize_t virtpci_driver_attr_store(struct kobject *kobj,
102 struct attribute *attr,
103 const char *buf, size_t count);
104 static int virtpci_bus_match(struct device *dev, struct device_driver *drv);
105 static int virtpci_uevent(struct device *dev, struct kobj_uevent_env *env);
106 static int virtpci_device_suspend(struct device *dev, pm_message_t state);
107 static int virtpci_device_resume(struct device *dev);
108 static int virtpci_device_probe(struct device *dev);
109 static int virtpci_device_remove(struct device *dev);
110
111 static ssize_t info_debugfs_read(struct file *file, char __user *buf,
112 size_t len, loff_t *offset);
113
114 static const struct file_operations debugfs_info_fops = {
115 .read = info_debugfs_read,
116 };
117
118 /*****************************************************/
119 /* Globals */
120 /*****************************************************/
121
122 /* methods in bus_type struct allow the bus code to serve as an
123 * intermediary between the device core and individual device core and
124 * individual drivers
125 */
126 static struct bus_type virtpci_bus_type = {
127 .name = "uisvirtpci",
128 .match = virtpci_bus_match,
129 .uevent = virtpci_uevent,
130 .suspend = virtpci_device_suspend,
131 .resume = virtpci_device_resume,
132 };
133
134 static struct device virtpci_rootbus_device = {
135 .init_name = "vbusroot", /* root bus */
136 .release = virtpci_bus_release
137 };
138
139 /* filled in with info about parent chipset driver when we register with it */
140 static struct ultra_vbus_deviceinfo Chipset_DriverInfo;
141
142 static const struct sysfs_ops virtpci_driver_sysfs_ops = {
143 .show = virtpci_driver_attr_show,
144 .store = virtpci_driver_attr_store,
145 };
146
147 static struct kobj_type virtpci_driver_kobj_type = {
148 .sysfs_ops = &virtpci_driver_sysfs_ops,
149 };
150
151 static struct virtpci_dev *VpcidevListHead;
152 static DEFINE_RWLOCK(VpcidevListLock);
153
154 /* filled in with info about this driver, wrt it servicing client busses */
155 static struct ultra_vbus_deviceinfo Bus_DriverInfo;
156
157 /*****************************************************/
158 /* debugfs entries */
159 /*****************************************************/
160 /* dentry is used to create the debugfs entry directory
161 * for virtpci
162 */
163 static struct dentry *virtpci_debugfs_dir;
164
165 struct virtpci_busdev {
166 struct device virtpci_bus_device;
167 };
168
169 /*****************************************************/
170 /* Local functions */
171 /*****************************************************/
172
173 static inline
174 int WAIT_FOR_IO_CHANNEL(struct spar_io_channel_protocol __iomem *chanptr)
175 {
176 int count = 120;
177
178 while (count > 0) {
179
180 if (SPAR_CHANNEL_SERVER_READY(&chanptr->channel_header))
181 return 1;
182 UIS_THREAD_WAIT_SEC(1);
183 count--;
184 }
185 return 0;
186 }
187
188 /* Write the contents of <info> to the ULTRA_VBUS_CHANNEL_PROTOCOL.ChpInfo. */
189 static int write_vbus_chpInfo(struct spar_vbus_channel_protocol *chan,
190 struct ultra_vbus_deviceinfo *info)
191 {
192 int off;
193
194 if (!chan) {
195 LOGERR("vbus channel not present");
196 return -1;
197 }
198 off = sizeof(struct channel_header) + chan->hdr_info.chp_info_offset;
199 if (chan->hdr_info.chp_info_offset == 0) {
200 LOGERR("vbus channel not used, because chp_info_offset == 0");
201 return -1;
202 }
203 memcpy(((u8 *) (chan)) + off, info, sizeof(*info));
204 return 0;
205 }
206
207 /* Write the contents of <info> to the ULTRA_VBUS_CHANNEL_PROTOCOL.BusInfo. */
208 static int write_vbus_busInfo(struct spar_vbus_channel_protocol *chan,
209 struct ultra_vbus_deviceinfo *info)
210 {
211 int off;
212
213 if (!chan) {
214 LOGERR("vbus channel not present");
215 return -1;
216 }
217 off = sizeof(struct channel_header) + chan->hdr_info.bus_info_offset;
218 if (chan->hdr_info.bus_info_offset == 0) {
219 LOGERR("vbus channel not used, because bus_info_offset == 0");
220 return -1;
221 }
222 memcpy(((u8 *) (chan)) + off, info, sizeof(*info));
223 return 0;
224 }
225
226 /* Write the contents of <info> to the
227 * ULTRA_VBUS_CHANNEL_PROTOCOL.DevInfo[<devix>].
228 */
229 static int
230 write_vbus_devInfo(struct spar_vbus_channel_protocol *chan,
231 struct ultra_vbus_deviceinfo *info, int devix)
232 {
233 int off;
234
235 if (!chan) {
236 LOGERR("vbus channel not present");
237 return -1;
238 }
239 off =
240 (sizeof(struct channel_header) +
241 chan->hdr_info.dev_info_offset) +
242 (chan->hdr_info.device_info_struct_bytes * devix);
243 if (chan->hdr_info.dev_info_offset == 0) {
244 LOGERR("vbus channel not used, because dev_info_offset == 0");
245 return -1;
246 }
247 memcpy(((u8 *) (chan)) + off, info, sizeof(*info));
248 return 0;
249 }
250
251 /* adds a vbus
252 * returns 0 failure, 1 success,
253 */
254 static int add_vbus(struct add_vbus_guestpart *addparams)
255 {
256 int ret;
257 struct device *vbus;
258
259 vbus = kzalloc(sizeof(struct device), GFP_ATOMIC);
260
261 POSTCODE_LINUX_2(VPCI_CREATE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
262 if (!vbus)
263 return 0;
264
265 dev_set_name(vbus, "vbus%d", addparams->bus_no);
266 vbus->release = virtpci_bus_release;
267 vbus->parent = &virtpci_rootbus_device; /* root bus is parent */
268 vbus->bus = &virtpci_bus_type; /* bus type */
269 vbus->platform_data = (__force void *)addparams->chanptr;
270
271 /* register a virt bus device -
272 * this bus shows up under /sys/devices with .name value
273 * "virtpci%d" any devices added to this bus then show up under
274 * /sys/devices/virtpci0
275 */
276 ret = device_register(vbus);
277 if (ret) {
278 LOGERR("device_register FAILED:%d\n", ret);
279 POSTCODE_LINUX_2(VPCI_CREATE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
280 return 0;
281 }
282 write_vbus_chpInfo(vbus->platform_data /* chanptr */ ,
283 &Chipset_DriverInfo);
284 write_vbus_busInfo(vbus->platform_data /* chanptr */ , &Bus_DriverInfo);
285 LOGINF("Added vbus %d; device %s created successfully\n",
286 addparams->bus_no, BUS_ID(vbus));
287 POSTCODE_LINUX_2(VPCI_CREATE_EXIT_PC, POSTCODE_SEVERITY_INFO);
288 return 1;
289 }
290
291 /* for CHANSOCK wwwnn/max are AUTO-GENERATED; for normal channels,
292 * wwnn/max are in the channel header.
293 */
294 #define GET_SCSIADAPINFO_FROM_CHANPTR(chanptr) { \
295 memcpy_fromio(&scsi.wwnn, \
296 &((struct spar_io_channel_protocol __iomem *) \
297 chanptr)->vhba.wwnn, \
298 sizeof(struct vhba_wwnn)); \
299 memcpy_fromio(&scsi.max, \
300 &((struct spar_io_channel_protocol __iomem *) \
301 chanptr)->vhba.max, \
302 sizeof(struct vhba_config_max)); \
303 }
304
305 /* find bus device with the busid that matches - match_busid matches bus_id */
306 #define GET_BUS_DEV(busno) { \
307 sprintf(busid, "vbus%d", busno); \
308 vbus = bus_find_device(&virtpci_bus_type, NULL, \
309 (void *)busid, match_busid); \
310 if (!vbus) { \
311 LOGERR("**** FAILED to find vbus %s\n", busid); \
312 return 0; \
313 } \
314 }
315
316 /* adds a vhba
317 * returns 0 failure, 1 success,
318 */
319 static int add_vhba(struct add_virt_guestpart *addparams)
320 {
321 int i;
322 struct scsi_adap_info scsi;
323 struct device *vbus;
324 unsigned char busid[BUS_ID_SIZE];
325
326 POSTCODE_LINUX_2(VPCI_CREATE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
327 if (!WAIT_FOR_IO_CHANNEL
328 ((struct spar_io_channel_protocol __iomem *) addparams->chanptr)) {
329 LOGERR("Timed out. Channel not ready\n");
330 POSTCODE_LINUX_2(VPCI_CREATE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
331 return 0;
332 }
333
334 GET_SCSIADAPINFO_FROM_CHANPTR(addparams->chanptr);
335
336 GET_BUS_DEV(addparams->bus_no);
337
338 LOGINF("Adding vhba wwnn:%x:%x config:%d-%d-%d-%d chanptr:%p\n",
339 scsi.wwnn.wwnn1, scsi.wwnn.wwnn2,
340 scsi.max.max_channel, scsi.max.max_id, scsi.max.max_lun,
341 scsi.max.cmd_per_lun, addparams->chanptr);
342 i = virtpci_device_add(vbus, VIRTHBA_TYPE, addparams, &scsi, NULL);
343 if (i) {
344 LOGINF("Added vhba wwnn:%x:%x chanptr:%p\n", scsi.wwnn.wwnn1,
345 scsi.wwnn.wwnn2, addparams->chanptr);
346 POSTCODE_LINUX_3(VPCI_CREATE_EXIT_PC, i,
347 POSTCODE_SEVERITY_INFO);
348 }
349 return i;
350
351 }
352
353 /* for CHANSOCK macaddr is AUTO-GENERATED; for normal channels,
354 * macaddr is in the channel header.
355 */
356 #define GET_NETADAPINFO_FROM_CHANPTR(chanptr) { \
357 memcpy_fromio(net.mac_addr, \
358 ((struct spar_io_channel_protocol __iomem *) \
359 chanptr)->vnic.macaddr, \
360 MAX_MACADDR_LEN); \
361 net.num_rcv_bufs = \
362 readl(&((struct spar_io_channel_protocol __iomem *)\
363 chanptr)->vnic.num_rcv_bufs); \
364 net.mtu = readl(&((struct spar_io_channel_protocol __iomem *) \
365 chanptr)->vnic.mtu); \
366 memcpy_fromio(&net.zone_uuid, \
367 &((struct spar_io_channel_protocol __iomem *)\
368 chanptr)->vnic.zone_uuid, \
369 sizeof(uuid_le)); \
370 }
371
372 /* adds a vnic
373 * returns 0 failure, 1 success,
374 */
375 static int
376 add_vnic(struct add_virt_guestpart *addparams)
377 {
378 int i;
379 struct net_adap_info net;
380 struct device *vbus;
381 unsigned char busid[BUS_ID_SIZE];
382
383 POSTCODE_LINUX_2(VPCI_CREATE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
384 if (!WAIT_FOR_IO_CHANNEL
385 ((struct spar_io_channel_protocol __iomem *) addparams->chanptr)) {
386 LOGERR("Timed out, channel not ready\n");
387 POSTCODE_LINUX_2(VPCI_CREATE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
388 return 0;
389 }
390
391 GET_NETADAPINFO_FROM_CHANPTR(addparams->chanptr);
392
393 GET_BUS_DEV(addparams->bus_no);
394
395 LOGINF("Adding vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x rcvbufs:%d mtu:%d chanptr:%p%pUL\n",
396 net.mac_addr[0], net.mac_addr[1], net.mac_addr[2], net.mac_addr[3],
397 net.mac_addr[4], net.mac_addr[5], net.num_rcv_bufs, net.mtu,
398 addparams->chanptr, &net.zone_uuid);
399 i = virtpci_device_add(vbus, VIRTNIC_TYPE, addparams, NULL, &net);
400 if (i) {
401 LOGINF("Added vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
402 net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
403 net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
404 POSTCODE_LINUX_3(VPCI_CREATE_EXIT_PC, i,
405 POSTCODE_SEVERITY_INFO);
406 return 1;
407 }
408 return 0;
409 }
410
411 /* delete vbus
412 * returns 0 failure, 1 success,
413 */
414 static int
415 delete_vbus(struct del_vbus_guestpart *delparams)
416 {
417 struct device *vbus;
418 unsigned char busid[BUS_ID_SIZE];
419
420 GET_BUS_DEV(delparams->bus_no);
421 /* ensure that bus has no devices? -- TBD */
422 LOGINF("Deleting %s\n", BUS_ID(vbus));
423 if (delete_vbus_device(vbus, NULL))
424 return 0; /* failure */
425 LOGINF("Deleted vbus %d\n", delparams->bus_no);
426 return 1;
427 }
428
429 static int
430 delete_vbus_device(struct device *vbus, void *data)
431 {
432 int checkforroot = (data != NULL);
433 struct device *pDev = &virtpci_rootbus_device;
434
435 if ((checkforroot) && match_busid(vbus, (void *) BUS_ID(pDev))) {
436 /* skip it - don't delete root bus */
437 LOGINF("skipping root bus\n");
438 return 0; /* pretend no error */
439 }
440 LOGINF("Calling unregister for %s\n", BUS_ID(vbus));
441 device_unregister(vbus);
442 kfree(vbus);
443 LOGINF("VBus unregister and freed\n");
444 return 0; /* no error */
445 }
446
447 /* pause vhba
448 * returns 0 failure, 1 success,
449 */
450 static int pause_vhba(struct pause_virt_guestpart *pauseparams)
451 {
452 int i;
453 struct scsi_adap_info scsi;
454
455 GET_SCSIADAPINFO_FROM_CHANPTR(pauseparams->chanptr);
456
457 LOGINF("Pausing vhba wwnn:%x:%x\n", scsi.wwnn.wwnn1, scsi.wwnn.wwnn2);
458 i = virtpci_device_serverdown(NULL /*no parent bus */ , VIRTHBA_TYPE,
459 &scsi.wwnn, NULL);
460 if (i)
461 LOGINF("Paused vhba wwnn:%x:%x\n", scsi.wwnn.wwnn1,
462 scsi.wwnn.wwnn2);
463 return i;
464 }
465
466 /* pause vnic
467 * returns 0 failure, 1 success,
468 */
469 static int pause_vnic(struct pause_virt_guestpart *pauseparams)
470 {
471 int i;
472 struct net_adap_info net;
473
474 GET_NETADAPINFO_FROM_CHANPTR(pauseparams->chanptr);
475
476 LOGINF("Pausing vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
477 net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
478 net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
479 i = virtpci_device_serverdown(NULL /*no parent bus */ , VIRTNIC_TYPE,
480 NULL, net.mac_addr);
481 if (i) {
482 LOGINF(" Paused vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
483 net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
484 net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
485 }
486 return i;
487 }
488
489 /* resume vhba
490 * returns 0 failure, 1 success,
491 */
492 static int resume_vhba(struct resume_virt_guestpart *resumeparams)
493 {
494 int i;
495 struct scsi_adap_info scsi;
496
497 GET_SCSIADAPINFO_FROM_CHANPTR(resumeparams->chanptr);
498
499 LOGINF("Resuming vhba wwnn:%x:%x\n", scsi.wwnn.wwnn1, scsi.wwnn.wwnn2);
500 i = virtpci_device_serverup(NULL /*no parent bus */ , VIRTHBA_TYPE,
501 &scsi.wwnn, NULL);
502 if (i)
503 LOGINF("Resumed vhba wwnn:%x:%x\n", scsi.wwnn.wwnn1,
504 scsi.wwnn.wwnn2);
505 return i;
506 }
507
508 /* resume vnic
509 * returns 0 failure, 1 success,
510 */
511 static int
512 resume_vnic(struct resume_virt_guestpart *resumeparams)
513 {
514 int i;
515 struct net_adap_info net;
516
517 GET_NETADAPINFO_FROM_CHANPTR(resumeparams->chanptr);
518
519 LOGINF("Resuming vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
520 net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
521 net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
522 i = virtpci_device_serverup(NULL /*no parent bus */ , VIRTNIC_TYPE,
523 NULL, net.mac_addr);
524 if (i) {
525 LOGINF(" Resumed vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
526 net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
527 net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
528 }
529 return i;
530 }
531
532 /* delete vhba
533 * returns 0 failure, 1 success,
534 */
535 static int delete_vhba(struct del_virt_guestpart *delparams)
536 {
537 int i;
538 struct scsi_adap_info scsi;
539
540 GET_SCSIADAPINFO_FROM_CHANPTR(delparams->chanptr);
541
542 LOGINF("Deleting vhba wwnn:%x:%x\n", scsi.wwnn.wwnn1, scsi.wwnn.wwnn2);
543 i = virtpci_device_del(NULL /*no parent bus */ , VIRTHBA_TYPE,
544 &scsi.wwnn, NULL);
545 if (i) {
546 LOGINF("Deleted vhba wwnn:%x:%x\n", scsi.wwnn.wwnn1,
547 scsi.wwnn.wwnn2);
548 return 1;
549 }
550 return 0;
551 }
552
553 /* deletes a vnic
554 * returns 0 failure, 1 success,
555 */
556 static int delete_vnic(struct del_virt_guestpart *delparams)
557 {
558 int i;
559 struct net_adap_info net;
560
561 GET_NETADAPINFO_FROM_CHANPTR(delparams->chanptr);
562
563 LOGINF("Deleting vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
564 net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
565 net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
566 i = virtpci_device_del(NULL /*no parent bus */ , VIRTNIC_TYPE, NULL,
567 net.mac_addr);
568 if (i) {
569 LOGINF("Deleted vnic macaddr:%02x:%02x:%02x:%02x:%02x:%02x\n",
570 net.mac_addr[0], net.mac_addr[1], net.mac_addr[2],
571 net.mac_addr[3], net.mac_addr[4], net.mac_addr[5]);
572 }
573 return i;
574 }
575
576 #define DELETE_ONE_VPCIDEV(vpcidev) { \
577 LOGINF("calling device_unregister:%p\n", &vpcidev->generic_dev); \
578 device_unregister(&vpcidev->generic_dev); \
579 LOGINF("Deleted %p\n", vpcidev); \
580 kfree(vpcidev); \
581 }
582
583 /* deletes all vhbas and vnics
584 * returns 0 failure, 1 success,
585 */
586 static void delete_all(void)
587 {
588 int count = 0;
589 unsigned long flags;
590 struct virtpci_dev *tmpvpcidev, *nextvpcidev;
591
592 /* delete the entire vhba/vnic list in one shot */
593 write_lock_irqsave(&VpcidevListLock, flags);
594 tmpvpcidev = VpcidevListHead;
595 VpcidevListHead = NULL;
596 write_unlock_irqrestore(&VpcidevListLock, flags);
597
598 /* delete one vhba/vnic at a time */
599 while (tmpvpcidev) {
600 nextvpcidev = tmpvpcidev->next;
601 /* delete the vhba/vnic at tmpvpcidev */
602 DELETE_ONE_VPCIDEV(tmpvpcidev);
603 tmpvpcidev = nextvpcidev;
604 count++;
605 }
606 LOGINF("Deleted %d vhbas/vnics.\n", count);
607
608 /* now delete each vbus */
609 if (bus_for_each_dev
610 (&virtpci_bus_type, NULL, (void *) 1, delete_vbus_device))
611 LOGERR("delete of all vbus failed\n");
612 }
613
614 /* deletes all vnics or vhbas
615 * returns 0 failure, 1 success,
616 */
617 static int delete_all_virt(enum virtpci_dev_type devtype,
618 struct del_vbus_guestpart *delparams)
619 {
620 int i;
621 unsigned char busid[BUS_ID_SIZE];
622 struct device *vbus;
623
624 GET_BUS_DEV(delparams->bus_no);
625
626 if ((devtype != VIRTHBA_TYPE) && (devtype != VIRTNIC_TYPE)) {
627 LOGERR("**** FAILED to delete all devices; devtype:%d not vhba:%d or vnic:%d\n",
628 devtype, VIRTHBA_TYPE, VIRTNIC_TYPE);
629 return 0;
630 }
631
632 LOGINF("Deleting all %s in vbus %s\n",
633 devtype == VIRTHBA_TYPE ? "vhbas" : "vnics", busid);
634 /* delete all vhbas/vnics */
635 i = virtpci_device_del(vbus, devtype, NULL, NULL);
636 if (i > 0)
637 LOGINF("Deleted %d %s\n", i,
638 devtype == VIRTHBA_TYPE ? "vhbas" : "vnics");
639 return 1;
640 }
641
642 static int virtpci_ctrlchan_func(struct guest_msgs *msg)
643 {
644 switch (msg->msgtype) {
645 case GUEST_ADD_VBUS:
646 return add_vbus(&msg->add_vbus);
647 case GUEST_ADD_VHBA:
648 return add_vhba(&msg->add_vhba);
649 case GUEST_ADD_VNIC:
650 return add_vnic(&msg->add_vnic);
651 case GUEST_DEL_VBUS:
652 return delete_vbus(&msg->del_vbus);
653 case GUEST_DEL_VHBA:
654 return delete_vhba(&msg->del_vhba);
655 case GUEST_DEL_VNIC:
656 return delete_vnic(&msg->del_vhba);
657 case GUEST_DEL_ALL_VHBAS:
658 return delete_all_virt(VIRTHBA_TYPE, &msg->del_all_vhbas);
659 case GUEST_DEL_ALL_VNICS:
660 return delete_all_virt(VIRTNIC_TYPE, &msg->del_all_vnics);
661 case GUEST_DEL_ALL_VBUSES:
662 delete_all();
663 return 1;
664 case GUEST_PAUSE_VHBA:
665 return pause_vhba(&msg->pause_vhba);
666 case GUEST_PAUSE_VNIC:
667 return pause_vnic(&msg->pause_vnic);
668 case GUEST_RESUME_VHBA:
669 return resume_vhba(&msg->resume_vhba);
670 case GUEST_RESUME_VNIC:
671 return resume_vnic(&msg->resume_vnic);
672 default:
673 LOGERR("invalid message type %d.\n", msg->msgtype);
674 return 0;
675 }
676 }
677
678 /* same as driver_helper in bus.c linux */
679 static int match_busid(struct device *dev, void *data)
680 {
681 const char *name = data;
682
683 if (strcmp(name, BUS_ID(dev)) == 0)
684 return 1;
685 return 0;
686 }
687
688 /*****************************************************/
689 /* Bus functions */
690 /*****************************************************/
691
692 static const struct pci_device_id *
693 virtpci_match_device(const struct pci_device_id *ids,
694 const struct virtpci_dev *dev)
695 {
696 while (ids->vendor || ids->subvendor || ids->class_mask) {
697 DBGINF("ids->vendor:%x dev->vendor:%x ids->device:%x dev->device:%x\n",
698 ids->vendor, dev->vendor, ids->device, dev->device);
699
700 if ((ids->vendor == dev->vendor)
701 && (ids->device == dev->device))
702 return ids;
703
704 ids++;
705 }
706 return NULL;
707 }
708
709 /* NOTE: !!!!!! This function is called when a new device is added
710 * for this bus. Or, it is called for existing devices when a new
711 * driver is added for this bus. It returns nonzero if a given device
712 * can be handled by the given driver.
713 */
714 static int virtpci_bus_match(struct device *dev, struct device_driver *drv)
715 {
716 struct virtpci_dev *virtpcidev = device_to_virtpci_dev(dev);
717 struct virtpci_driver *virtpcidrv = driver_to_virtpci_driver(drv);
718 int match = 0;
719
720 DBGINF("In virtpci_bus_match dev->bus_id:%s drv->name:%s\n",
721 dev->bus_id, drv->name);
722
723 /* check ids list for a match */
724 if (virtpci_match_device(virtpcidrv->id_table, virtpcidev))
725 match = 1;
726
727 DBGINF("returning match:%d\n", match);
728 return match; /* 0 - no match; 1 - yes it matches */
729 }
730
731 static int virtpci_uevent(struct device *dev, struct kobj_uevent_env *env)
732 {
733 DBGINF("In virtpci_hotplug\n");
734 /* add variables to the environment prior to the generation of
735 * hotplug events to user space
736 */
737 if (add_uevent_var(env, "VIRTPCI_VERSION=%s", VIRTPCI_VERSION))
738 return -ENOMEM;
739 return 0;
740 }
741
742 static int virtpci_device_suspend(struct device *dev, pm_message_t state)
743 {
744 DBGINF("In virtpci_device_suspend -NYI ****\n");
745 return 0;
746 }
747
748 static int virtpci_device_resume(struct device *dev)
749 {
750 DBGINF("In virtpci_device_resume -NYI ****\n");
751 return 0;
752 }
753
754 /* For a child device just created on a client bus, fill in
755 * information about the driver that is controlling this device into
756 * the appropriate slot within the vbus channel of the bus
757 * instance.
758 */
759 static void fix_vbus_devInfo(struct device *dev, int devNo, int devType,
760 struct virtpci_driver *virtpcidrv)
761 {
762 struct device *vbus;
763 void *pChan;
764 struct ultra_vbus_deviceinfo devInfo;
765 const char *stype;
766
767 if (!dev) {
768 LOGERR("%s dev is NULL", __func__);
769 return;
770 }
771 if (!virtpcidrv) {
772 LOGERR("%s driver is NULL", __func__);
773 return;
774 }
775 vbus = dev->parent;
776 if (!vbus) {
777 LOGERR("%s dev has no parent bus", __func__);
778 return;
779 }
780 pChan = vbus->platform_data;
781 if (!pChan) {
782 LOGERR("%s dev bus has no channel", __func__);
783 return;
784 }
785 switch (devType) {
786 case PCI_DEVICE_ID_VIRTHBA:
787 stype = "vHBA";
788 break;
789 case PCI_DEVICE_ID_VIRTNIC:
790 stype = "vNIC";
791 break;
792 default:
793 stype = "unknown";
794 break;
795 }
796 bus_device_info_init(&devInfo, stype,
797 virtpcidrv->name,
798 virtpcidrv->version,
799 virtpcidrv->vertag);
800 write_vbus_devInfo(pChan, &devInfo, devNo);
801
802 /* Re-write bus+chipset info, because it is possible that this
803 * was previously written by our good counterpart, visorbus.
804 */
805 write_vbus_chpInfo(pChan, &Chipset_DriverInfo);
806 write_vbus_busInfo(pChan, &Bus_DriverInfo);
807 }
808
809 /* This function is called to query the existence of a specific device
810 * and whether this driver can work with it. It should return -ENODEV
811 * in case of failure.
812 */
813 static int virtpci_device_probe(struct device *dev)
814 {
815 struct virtpci_dev *virtpcidev = device_to_virtpci_dev(dev);
816 struct virtpci_driver *virtpcidrv =
817 driver_to_virtpci_driver(dev->driver);
818 const struct pci_device_id *id;
819 int error = 0;
820
821 LOGINF("In virtpci_device_probe dev:%p virtpcidev:%p virtpcidrv:%p\n",
822 dev, virtpcidev, virtpcidrv); /* VERBOSE/DEBUG ? */
823 POSTCODE_LINUX_2(VPCI_PROBE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
824 /* static match and static probe vs dynamic match & dynamic
825 * probe - do we care?.
826 */
827 if (!virtpcidrv->id_table)
828 return -ENODEV;
829
830 id = virtpci_match_device(virtpcidrv->id_table, virtpcidev);
831 if (!id)
832 return -ENODEV;
833
834 /* increment reference count */
835 get_device(dev);
836
837 /* if virtpcidev is not already claimed & probe function is
838 * valid, probe it
839 */
840 if (!virtpcidev->mydriver && virtpcidrv->probe) {
841 /* call the probe function - virthba or virtnic probe
842 * is what it should be
843 */
844 error = virtpcidrv->probe(virtpcidev, id);
845 if (!error) {
846 fix_vbus_devInfo(dev, virtpcidev->device_no,
847 virtpcidev->device, virtpcidrv);
848 virtpcidev->mydriver = virtpcidrv;
849 POSTCODE_LINUX_2(VPCI_PROBE_EXIT_PC,
850 POSTCODE_SEVERITY_INFO);
851 } else
852 put_device(dev);
853 }
854 POSTCODE_LINUX_2(VPCI_PROBE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
855 return error; /* -ENODEV for probe failure */
856 }
857
858 static int virtpci_device_remove(struct device *dev_)
859 {
860 /* dev_ passed in is the HBA device which we called
861 * generic_dev in our virtpcidev struct
862 */
863 struct virtpci_dev *virtpcidev = device_to_virtpci_dev(dev_);
864 struct virtpci_driver *virtpcidrv = virtpcidev->mydriver;
865
866 LOGINF("In virtpci_device_remove bus_id:%s dev_:%p virtpcidev:%p dev->driver:%p drivername:%s\n",
867 BUS_ID(dev_), dev_, virtpcidev, dev_->driver,
868 dev_->driver->name); /* VERBOSE/DEBUG */
869 if (virtpcidrv) {
870 /* TEMP: assuming we have only one such driver for now */
871 if (virtpcidrv->remove)
872 virtpcidrv->remove(virtpcidev);
873 virtpcidev->mydriver = NULL;
874 }
875
876 DBGINF("calling putdevice\n");
877 put_device(dev_);
878
879 DBGINF("Leaving\n");
880 return 0;
881 }
882
883 /*****************************************************/
884 /* Bus functions */
885 /*****************************************************/
886
887 static void virtpci_bus_release(struct device *dev)
888 {
889 /* this function is called when the last reference to the
890 * device is removed
891 */
892 DBGINF("In virtpci_bus_release\n");
893 /* what else is supposed to happen here? */
894 }
895
896 /*****************************************************/
897 /* Adapter functions */
898 /*****************************************************/
899
900 static int virtpci_device_add(struct device *parentbus, int devtype,
901 struct add_virt_guestpart *addparams,
902 struct scsi_adap_info *scsi, /* NULL for VNIC add */
903 struct net_adap_info *net /* NULL for VHBA add */)
904 {
905 struct virtpci_dev *virtpcidev = NULL;
906 struct virtpci_dev *tmpvpcidev = NULL, *prev;
907 unsigned long flags;
908 int ret;
909 struct spar_io_channel_protocol __iomem *pIoChan = NULL;
910 struct device *pDev;
911
912 LOGINF("virtpci_device_add parentbus:%p chanptr:%p\n", parentbus,
913 addparams->chanptr);
914
915 POSTCODE_LINUX_2(VPCI_CREATE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
916
917 if ((devtype != VIRTHBA_TYPE) && (devtype != VIRTNIC_TYPE)) {
918 LOGERR("**** FAILED to add device; devtype:%d not vhba:%d or vnic:%d\n",
919 devtype, VIRTHBA_TYPE, VIRTNIC_TYPE);
920 POSTCODE_LINUX_3(VPCI_CREATE_FAILURE_PC, devtype,
921 POSTCODE_SEVERITY_ERR);
922 return 0;
923 }
924
925 /* add a Virtual Device */
926 virtpcidev = kzalloc(sizeof(struct virtpci_dev), GFP_ATOMIC);
927 if (virtpcidev == NULL) {
928 LOGERR("can't add device - malloc FALLED\n");
929 POSTCODE_LINUX_2(MALLOC_FAILURE_PC, POSTCODE_SEVERITY_ERR);
930 return 0;
931 }
932
933 /* initialize stuff unique to virtpci_dev struct */
934 virtpcidev->devtype = devtype;
935 if (devtype == VIRTHBA_TYPE) {
936 virtpcidev->device = PCI_DEVICE_ID_VIRTHBA;
937 virtpcidev->scsi = *scsi;
938 } else {
939 virtpcidev->device = PCI_DEVICE_ID_VIRTNIC;
940 virtpcidev->net = *net;
941 }
942 virtpcidev->vendor = PCI_VENDOR_ID_UNISYS;
943 virtpcidev->bus_no = addparams->bus_no;
944 virtpcidev->device_no = addparams->device_no;
945
946 virtpcidev->queueinfo.chan = addparams->chanptr;
947 virtpcidev->queueinfo.send_int_if_needed = NULL;
948
949 /* Set up safe queue... */
950 pIoChan = (struct spar_io_channel_protocol __iomem *)
951 virtpcidev->queueinfo.chan;
952
953 virtpcidev->intr = addparams->intr;
954
955 /* initialize stuff in the device portion of the struct */
956 virtpcidev->generic_dev.bus = &virtpci_bus_type;
957 virtpcidev->generic_dev.parent = parentbus;
958 virtpcidev->generic_dev.release = virtpci_device_release;
959
960 dev_set_name(&virtpcidev->generic_dev, "%x:%x",
961 addparams->bus_no, addparams->device_no);
962
963 /* add the vhba/vnic to virtpci device list - but check for
964 * duplicate wwnn/macaddr first
965 */
966 write_lock_irqsave(&VpcidevListLock, flags);
967 for (tmpvpcidev = VpcidevListHead; tmpvpcidev;
968 tmpvpcidev = tmpvpcidev->next) {
969 if (devtype == VIRTHBA_TYPE) {
970 if ((tmpvpcidev->scsi.wwnn.wwnn1 == scsi->wwnn.wwnn1) &&
971 (tmpvpcidev->scsi.wwnn.wwnn2 == scsi->wwnn.wwnn2)) {
972 /* duplicate - already have vpcidev
973 with this wwnn */
974 break;
975 }
976 } else
977 if (memcmp
978 (tmpvpcidev->net.mac_addr, net->mac_addr,
979 MAX_MACADDR_LEN) == 0) {
980 /* duplicate - already have vnic with this wwnn */
981 break;
982 }
983 }
984 if (tmpvpcidev) {
985 /* found a vhba/vnic already in the list with same
986 * wwnn or macaddr - reject add
987 */
988 write_unlock_irqrestore(&VpcidevListLock, flags);
989 kfree(virtpcidev);
990 LOGERR("**** FAILED vhba/vnic already exists in the list\n");
991 POSTCODE_LINUX_2(VPCI_CREATE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
992 return 0;
993 }
994
995 /* add it at the head */
996 if (!VpcidevListHead)
997 VpcidevListHead = virtpcidev;
998 else {
999 /* insert virtpcidev at the head of our linked list of
1000 * vpcidevs
1001 */
1002 virtpcidev->next = VpcidevListHead;
1003 VpcidevListHead = virtpcidev;
1004 }
1005
1006 write_unlock_irqrestore(&VpcidevListLock, flags);
1007
1008 /* Must transition channel to ATTACHED state BEFORE
1009 * registering the device, because polling of the channel
1010 * queues can begin at any time after device_register().
1011 */
1012 pDev = &virtpcidev->generic_dev;
1013 SPAR_CHANNEL_CLIENT_TRANSITION(addparams->chanptr,
1014 BUS_ID(pDev),
1015 CHANNELCLI_ATTACHED, NULL);
1016
1017 /* don't register until device has been added to
1018 * list. Otherwise, a device_unregister from this function can
1019 * cause a "scheduling while atomic".
1020 */
1021 DBGINF("registering device:%p with bus_id:%s\n",
1022 &virtpcidev->generic_dev, virtpcidev->generic_dev.bus_id);
1023 ret = device_register(&virtpcidev->generic_dev);
1024 /* NOTE: THIS IS CALLING HOTPLUG virtpci_hotplug!!!
1025 * This call to device_register results in virtpci_bus_match
1026 * being called !!!!! And, if match returns success, then
1027 * virtpcidev->generic_dev.driver is setup to core_driver,
1028 * i.e., virtpci and the probe function
1029 * virtpcidev->generic_dev.driver->probe is called which
1030 * results in virtpci_device_probe being called. And if
1031 * virtpci_device_probe is successful
1032 */
1033 if (ret) {
1034 LOGERR("device_register returned %d\n", ret);
1035 pDev = &virtpcidev->generic_dev;
1036 SPAR_CHANNEL_CLIENT_TRANSITION(addparams->chanptr,
1037 BUS_ID(pDev),
1038 CHANNELCLI_DETACHED, NULL);
1039 /* remove virtpcidev, the one we just added, from the list */
1040 write_lock_irqsave(&VpcidevListLock, flags);
1041 for (tmpvpcidev = VpcidevListHead, prev = NULL;
1042 tmpvpcidev;
1043 prev = tmpvpcidev, tmpvpcidev = tmpvpcidev->next) {
1044 if (tmpvpcidev == virtpcidev) {
1045 if (prev)
1046 prev->next = tmpvpcidev->next;
1047 else
1048 VpcidevListHead = tmpvpcidev->next;
1049 break;
1050 }
1051 }
1052 write_unlock_irqrestore(&VpcidevListLock, flags);
1053 kfree(virtpcidev);
1054 return 0;
1055 }
1056
1057 LOGINF("Added %s:%d:%d &virtpcidev->generic_dev:%p\n",
1058 (devtype == VIRTHBA_TYPE) ? "virthba" : "virtnic",
1059 addparams->bus_no, addparams->device_no,
1060 &virtpcidev->generic_dev);
1061 POSTCODE_LINUX_2(VPCI_CREATE_EXIT_PC, POSTCODE_SEVERITY_INFO);
1062 return 1;
1063 }
1064
1065 static int virtpci_device_serverdown(struct device *parentbus,
1066 int devtype,
1067 struct vhba_wwnn *wwnn,
1068 unsigned char macaddr[])
1069 {
1070 int pausethisone = 0;
1071 bool found = false;
1072 struct virtpci_dev *tmpvpcidev, *prevvpcidev;
1073 struct virtpci_driver *vpcidriver;
1074 unsigned long flags;
1075 int rc = 0;
1076
1077 if ((devtype != VIRTHBA_TYPE) && (devtype != VIRTNIC_TYPE)) {
1078 LOGERR("**** FAILED to pause device; devtype:%d not vhba:%d or vnic:%d\n",
1079 devtype, VIRTHBA_TYPE, VIRTNIC_TYPE);
1080 return 0;
1081 }
1082
1083 /* find the vhba or vnic in virtpci device list */
1084 write_lock_irqsave(&VpcidevListLock, flags);
1085
1086 for (tmpvpcidev = VpcidevListHead, prevvpcidev = NULL;
1087 (tmpvpcidev && !found);
1088 prevvpcidev = tmpvpcidev, tmpvpcidev = tmpvpcidev->next) {
1089 if (tmpvpcidev->devtype != devtype)
1090 continue;
1091
1092 if (devtype == VIRTHBA_TYPE) {
1093 pausethisone =
1094 ((tmpvpcidev->scsi.wwnn.wwnn1 == wwnn->wwnn1) &&
1095 (tmpvpcidev->scsi.wwnn.wwnn2 == wwnn->wwnn2));
1096 /* devtype is vhba, we're pausing vhba whose
1097 * wwnn matches the current device's wwnn
1098 */
1099 } else { /* VIRTNIC_TYPE */
1100 pausethisone =
1101 memcmp(tmpvpcidev->net.mac_addr, macaddr,
1102 MAX_MACADDR_LEN) == 0;
1103 /* devtype is vnic, we're pausing vnic whose
1104 * macaddr matches the current device's macaddr */
1105 }
1106
1107 if (!pausethisone)
1108 continue;
1109
1110 found = true;
1111 vpcidriver = tmpvpcidev->mydriver;
1112 rc = vpcidriver->suspend(tmpvpcidev, 0);
1113 }
1114 write_unlock_irqrestore(&VpcidevListLock, flags);
1115
1116 if (!found) {
1117 LOGERR("**** FAILED to find vhba/vnic in the list\n");
1118 return 0;
1119 }
1120
1121 return rc;
1122 }
1123
1124 static int virtpci_device_serverup(struct device *parentbus,
1125 int devtype,
1126 struct vhba_wwnn *wwnn,
1127 unsigned char macaddr[])
1128 {
1129 int resumethisone = 0;
1130 bool found = false;
1131 struct virtpci_dev *tmpvpcidev, *prevvpcidev;
1132 struct virtpci_driver *vpcidriver;
1133 unsigned long flags;
1134 int rc = 0;
1135
1136 if ((devtype != VIRTHBA_TYPE) && (devtype != VIRTNIC_TYPE)) {
1137 LOGERR("**** FAILED to resume device; devtype:%d not vhba:%d or vnic:%d\n",
1138 devtype, VIRTHBA_TYPE, VIRTNIC_TYPE);
1139 return 0;
1140 }
1141
1142 /* find the vhba or vnic in virtpci device list */
1143 write_lock_irqsave(&VpcidevListLock, flags);
1144
1145 for (tmpvpcidev = VpcidevListHead, prevvpcidev = NULL;
1146 (tmpvpcidev && !found);
1147 prevvpcidev = tmpvpcidev, tmpvpcidev = tmpvpcidev->next) {
1148 if (tmpvpcidev->devtype != devtype)
1149 continue;
1150
1151 if (devtype == VIRTHBA_TYPE) {
1152 resumethisone =
1153 ((tmpvpcidev->scsi.wwnn.wwnn1 == wwnn->wwnn1) &&
1154 (tmpvpcidev->scsi.wwnn.wwnn2 == wwnn->wwnn2));
1155 /* devtype is vhba, we're resuming vhba whose
1156 * wwnn matches the current device's wwnn */
1157 } else { /* VIRTNIC_TYPE */
1158 resumethisone =
1159 memcmp(tmpvpcidev->net.mac_addr, macaddr,
1160 MAX_MACADDR_LEN) == 0;
1161 /* devtype is vnic, we're resuming vnic whose
1162 * macaddr matches the current device's macaddr */
1163 }
1164
1165 if (!resumethisone)
1166 continue;
1167
1168 found = true;
1169 vpcidriver = tmpvpcidev->mydriver;
1170 /* This should be done at BUS resume time, but an
1171 * existing problem prevents us from ever getting a bus
1172 * resume... This hack would fail to work should we
1173 * ever have a bus that contains NO devices, since we
1174 * would never even get here in that case.
1175 */
1176 fix_vbus_devInfo(&tmpvpcidev->generic_dev,
1177 tmpvpcidev->device_no,
1178 tmpvpcidev->device, vpcidriver);
1179 rc = vpcidriver->resume(tmpvpcidev);
1180 }
1181
1182 write_unlock_irqrestore(&VpcidevListLock, flags);
1183
1184 if (!found) {
1185 LOGERR("**** FAILED to find vhba/vnic in the list\n");
1186 return 0;
1187 }
1188
1189 return rc;
1190 }
1191
1192 static int virtpci_device_del(struct device *parentbus,
1193 int devtype, struct vhba_wwnn *wwnn,
1194 unsigned char macaddr[])
1195 {
1196 int count = 0, all = 0, delthisone;
1197 struct virtpci_dev *tmpvpcidev, *prevvpcidev, *dellist = NULL;
1198 unsigned long flags;
1199
1200 #define DEL_CONTINUE { \
1201 prevvpcidev = tmpvpcidev;\
1202 tmpvpcidev = tmpvpcidev->next;\
1203 continue; \
1204 }
1205
1206 if ((devtype != VIRTHBA_TYPE) && (devtype != VIRTNIC_TYPE)) {
1207 LOGERR("**** FAILED to delete device; devtype:%d not vhba:%d or vnic:%d\n",
1208 devtype, VIRTHBA_TYPE, VIRTNIC_TYPE);
1209 return 0;
1210 }
1211
1212 /* see if we are to delete all - NOTE: all implies we have a
1213 * valid parentbus
1214 */
1215 all = ((devtype == VIRTHBA_TYPE) && (wwnn == NULL)) ||
1216 ((devtype == VIRTNIC_TYPE) && (macaddr == NULL));
1217
1218 /* find all the vhba or vnic or both in virtpci device list
1219 * keep list of ones we are deleting so we can call
1220 * device_unregister after we release the lock; otherwise we
1221 * encounter "schedule while atomic"
1222 */
1223 write_lock_irqsave(&VpcidevListLock, flags);
1224 for (tmpvpcidev = VpcidevListHead, prevvpcidev = NULL; tmpvpcidev;) {
1225 if (tmpvpcidev->devtype != devtype)
1226 DEL_CONTINUE;
1227
1228 if (all) {
1229 delthisone =
1230 (tmpvpcidev->generic_dev.parent == parentbus);
1231 /* we're deleting all vhbas or vnics on the
1232 * specified parent bus
1233 */
1234 } else if (devtype == VIRTHBA_TYPE) {
1235 delthisone =
1236 ((tmpvpcidev->scsi.wwnn.wwnn1 == wwnn->wwnn1) &&
1237 (tmpvpcidev->scsi.wwnn.wwnn2 == wwnn->wwnn2));
1238 /* devtype is vhba, we're deleting vhba whose
1239 * wwnn matches the current device's wwnn
1240 */
1241 } else { /* VIRTNIC_TYPE */
1242 delthisone =
1243 memcmp(tmpvpcidev->net.mac_addr, macaddr,
1244 MAX_MACADDR_LEN) == 0;
1245 /* devtype is vnic, we're deleting vnic whose
1246 * macaddr matches the current device's macaddr
1247 */
1248 }
1249
1250 if (!delthisone)
1251 DEL_CONTINUE;
1252
1253 /* take vhba/vnic out of the list */
1254 if (prevvpcidev)
1255 /* not at head */
1256 prevvpcidev->next = tmpvpcidev->next;
1257 else
1258 VpcidevListHead = tmpvpcidev->next;
1259
1260 /* add it to our deletelist */
1261 tmpvpcidev->next = dellist;
1262 dellist = tmpvpcidev;
1263
1264 count++;
1265 if (!all)
1266 break; /* done */
1267 /* going to top of loop again - set tmpvpcidev to next
1268 * one we're to process
1269 */
1270 if (prevvpcidev)
1271 tmpvpcidev = prevvpcidev->next;
1272 else
1273 tmpvpcidev = VpcidevListHead;
1274 }
1275 write_unlock_irqrestore(&VpcidevListLock, flags);
1276
1277 if (!all && (count == 0)) {
1278 LOGERR("**** FAILED to find vhba/vnic in the list\n");
1279 return 0;
1280 }
1281
1282 /* now delete each one from delete list */
1283 while (dellist) {
1284 /* save next */
1285 tmpvpcidev = dellist->next;
1286 /* delete the vhba/vnic at dellist */
1287 DELETE_ONE_VPCIDEV(dellist);
1288 /* do next */
1289 dellist = tmpvpcidev;
1290 }
1291
1292 return count;
1293 }
1294
1295 static void virtpci_device_release(struct device *dev_)
1296 {
1297 /* this function is called when the last reference to the
1298 * device is removed
1299 */
1300 LOGINF("In virtpci_device_release:%p - NOT YET IMPLEMENTED\n", dev_);
1301 }
1302
1303 /*****************************************************/
1304 /* Driver functions */
1305 /*****************************************************/
1306
1307 #define kobj_to_device_driver(obj) container_of(obj, struct device_driver, kobj)
1308 #define attribute_to_driver_attribute(obj) \
1309 container_of(obj, struct driver_attribute, attr)
1310
1311 static ssize_t virtpci_driver_attr_show(struct kobject *kobj,
1312 struct attribute *attr,
1313 char *buf)
1314 {
1315 struct driver_attribute *dattr = attribute_to_driver_attribute(attr);
1316 ssize_t ret = 0;
1317
1318 struct driver_private *dprivate = to_driver(kobj);
1319 struct device_driver *driver;
1320
1321 if (dprivate != NULL)
1322 driver = dprivate->driver;
1323 else
1324 driver = NULL;
1325
1326 DBGINF("In virtpci_driver_attr_show driver->name:%s\n", driver->name);
1327 if (driver) {
1328 if (dattr->show)
1329 ret = dattr->show(driver, buf);
1330 }
1331 return ret;
1332 }
1333
1334 static ssize_t virtpci_driver_attr_store(struct kobject *kobj,
1335 struct attribute *attr,
1336 const char *buf, size_t count)
1337 {
1338 struct driver_attribute *dattr = attribute_to_driver_attribute(attr);
1339 ssize_t ret = 0;
1340
1341 struct driver_private *dprivate = to_driver(kobj);
1342 struct device_driver *driver;
1343
1344 if (dprivate != NULL)
1345 driver = dprivate->driver;
1346 else
1347 driver = NULL;
1348
1349 DBGINF("In virtpci_driver_attr_store driver->name:%s\n", driver->name);
1350
1351 if (driver) {
1352 if (dattr->store)
1353 ret = dattr->store(driver, buf, count);
1354 }
1355 return ret;
1356 }
1357
1358 /* register a new virtpci driver */
1359 int virtpci_register_driver(struct virtpci_driver *drv)
1360 {
1361 int result = 0;
1362
1363 DBGINF("In virtpci_register_driver\n");
1364
1365 if (drv->id_table == NULL) {
1366 LOGERR("id_table missing\n");
1367 return 1;
1368 }
1369 /* initialize core driver fields needed to call driver_register */
1370 drv->core_driver.name = drv->name; /* name of driver in sysfs */
1371 drv->core_driver.bus = &virtpci_bus_type; /* type of bus this
1372 * driver works with */
1373 drv->core_driver.probe = virtpci_device_probe; /* called to query the
1374 * existence of a
1375 * specific device and
1376 * whether this driver
1377 *can work with it */
1378 drv->core_driver.remove = virtpci_device_remove; /* called when the
1379 * device is removed
1380 * from the system */
1381 /* register with core */
1382 result = driver_register(&drv->core_driver);
1383 /* calls bus_add_driver which calls driver_attach and
1384 * module_add_driver
1385 */
1386 if (result)
1387 return result; /* failed */
1388
1389 drv->core_driver.p->kobj.ktype = &virtpci_driver_kobj_type;
1390
1391 return 0;
1392 }
1393 EXPORT_SYMBOL_GPL(virtpci_register_driver);
1394
1395 void virtpci_unregister_driver(struct virtpci_driver *drv)
1396 {
1397 DBGINF("In virtpci_unregister_driver drv:%p\n", drv);
1398 driver_unregister(&drv->core_driver);
1399 /* driver_unregister calls bus_remove_driver
1400 * bus_remove_driver calls device_detach
1401 * device_detach calls device_release_driver for each of the
1402 * driver's devices
1403 * device_release driver calls drv->remove which is
1404 * virtpci_device_remove
1405 * virtpci_device_remove calls virthba_remove
1406 */
1407 DBGINF("Leaving\n");
1408 }
1409 EXPORT_SYMBOL_GPL(virtpci_unregister_driver);
1410
1411 /*****************************************************/
1412 /* debugfs filesystem functions */
1413 /*****************************************************/
1414 struct print_vbus_info {
1415 int *str_pos;
1416 char *buf;
1417 size_t *len;
1418 };
1419
1420 static int print_vbus(struct device *vbus, void *data)
1421 {
1422 struct print_vbus_info *p = (struct print_vbus_info *)data;
1423
1424 *p->str_pos += scnprintf(p->buf + *p->str_pos, *p->len - *p->str_pos,
1425 "bus_id:%s\n", dev_name(vbus));
1426 return 0;
1427 }
1428
1429 static ssize_t info_debugfs_read(struct file *file, char __user *buf,
1430 size_t len, loff_t *offset)
1431 {
1432 ssize_t bytes_read = 0;
1433 int str_pos = 0;
1434 struct virtpci_dev *tmpvpcidev;
1435 unsigned long flags;
1436 struct print_vbus_info printparam;
1437 char *vbuf;
1438
1439 if (len > MAX_BUF)
1440 len = MAX_BUF;
1441 vbuf = kzalloc(len, GFP_KERNEL);
1442 if (!vbuf)
1443 return -ENOMEM;
1444
1445 str_pos += scnprintf(vbuf + str_pos, len - str_pos,
1446 " Virtual PCI Bus devices\n");
1447 printparam.str_pos = &str_pos;
1448 printparam.buf = vbuf;
1449 printparam.len = &len;
1450 if (bus_for_each_dev(&virtpci_bus_type, NULL,
1451 (void *) &printparam, print_vbus))
1452 LOGERR("Failed to find bus\n");
1453
1454 str_pos += scnprintf(vbuf + str_pos, len - str_pos,
1455 "\n Virtual PCI devices\n");
1456 read_lock_irqsave(&VpcidevListLock, flags);
1457 tmpvpcidev = VpcidevListHead;
1458 while (tmpvpcidev) {
1459 if (tmpvpcidev->devtype == VIRTHBA_TYPE) {
1460 str_pos += scnprintf(vbuf + str_pos, len - str_pos,
1461 "[%d:%d] VHba:%08x:%08x max-config:%d-%d-%d-%d",
1462 tmpvpcidev->bus_no,
1463 tmpvpcidev->device_no,
1464 tmpvpcidev->scsi.wwnn.wwnn1,
1465 tmpvpcidev->scsi.wwnn.wwnn2,
1466 tmpvpcidev->scsi.max.max_channel,
1467 tmpvpcidev->scsi.max.max_id,
1468 tmpvpcidev->scsi.max.max_lun,
1469 tmpvpcidev->scsi.max.cmd_per_lun);
1470 } else {
1471 str_pos += scnprintf(vbuf + str_pos, len - str_pos,
1472 "[%d:%d] VNic:%02x:%02x:%02x:%02x:%02x:%02x num_rcv_bufs:%d mtu:%d",
1473 tmpvpcidev->bus_no,
1474 tmpvpcidev->device_no,
1475 tmpvpcidev->net.mac_addr[0],
1476 tmpvpcidev->net.mac_addr[1],
1477 tmpvpcidev->net.mac_addr[2],
1478 tmpvpcidev->net.mac_addr[3],
1479 tmpvpcidev->net.mac_addr[4],
1480 tmpvpcidev->net.mac_addr[5],
1481 tmpvpcidev->net.num_rcv_bufs,
1482 tmpvpcidev->net.mtu);
1483 }
1484 str_pos += scnprintf(vbuf + str_pos,
1485 len - str_pos, " chanptr:%p\n",
1486 tmpvpcidev->queueinfo.chan);
1487 tmpvpcidev = tmpvpcidev->next;
1488 }
1489 read_unlock_irqrestore(&VpcidevListLock, flags);
1490
1491 str_pos += scnprintf(vbuf + str_pos, len - str_pos, "\n");
1492 bytes_read = simple_read_from_buffer(buf, len, offset, vbuf, str_pos);
1493 kfree(vbuf);
1494 return bytes_read;
1495 }
1496
1497 /*****************************************************/
1498 /* Module Init & Exit functions */
1499 /*****************************************************/
1500
1501 static int __init virtpci_mod_init(void)
1502 {
1503 int ret;
1504
1505
1506 if (!unisys_spar_platform)
1507 return -ENODEV;
1508
1509 POSTCODE_LINUX_2(VPCI_CREATE_ENTRY_PC, POSTCODE_SEVERITY_INFO);
1510
1511 ret = bus_register(&virtpci_bus_type);
1512 /* creates /sys/bus/uisvirtpci which contains devices &
1513 * drivers directory
1514 */
1515 if (ret) {
1516 LOGERR("bus_register ****FAILED:%d\n", ret);
1517 POSTCODE_LINUX_3(VPCI_CREATE_FAILURE_PC, ret,
1518 POSTCODE_SEVERITY_ERR);
1519 return ret;
1520 }
1521 DBGINF("bus_register successful\n");
1522 bus_device_info_init(&Bus_DriverInfo, "clientbus", "virtpci",
1523 VERSION, NULL);
1524
1525 /* create a root bus used to parent all the virtpci buses. */
1526 ret = device_register(&virtpci_rootbus_device);
1527 if (ret) {
1528 LOGERR("device_register FAILED:%d\n", ret);
1529 bus_unregister(&virtpci_bus_type);
1530 POSTCODE_LINUX_3(VPCI_CREATE_FAILURE_PC, ret,
1531 POSTCODE_SEVERITY_ERR);
1532 return ret;
1533 }
1534 DBGINF("device_register successful ret:%x\n", ret);
1535
1536 if (!uisctrl_register_req_handler(2, (void *) &virtpci_ctrlchan_func,
1537 &Chipset_DriverInfo)) {
1538 LOGERR("uisctrl_register_req_handler ****FAILED.\n");
1539 POSTCODE_LINUX_2(VPCI_CREATE_FAILURE_PC, POSTCODE_SEVERITY_ERR);
1540 device_unregister(&virtpci_rootbus_device);
1541 bus_unregister(&virtpci_bus_type);
1542 return -1;
1543 }
1544
1545 LOGINF("successfully registered virtpci_ctrlchan_func (0x%p) as callback.\n",
1546 (void *) &virtpci_ctrlchan_func);
1547 /* create debugfs directory and info file inside. */
1548 virtpci_debugfs_dir = debugfs_create_dir("virtpci", NULL);
1549 debugfs_create_file("info", S_IRUSR, virtpci_debugfs_dir,
1550 NULL, &debugfs_info_fops);
1551 LOGINF("Leaving\n");
1552 POSTCODE_LINUX_2(VPCI_CREATE_EXIT_PC, POSTCODE_SEVERITY_INFO);
1553 return 0;
1554 }
1555
1556 static void __exit virtpci_mod_exit(void)
1557 {
1558 LOGINF("virtpci_mod_exit...\n");
1559
1560 /* unregister the callback function */
1561 if (!uisctrl_register_req_handler(2, NULL, NULL))
1562 LOGERR("uisctrl_register_req_handler ****FAILED.\n");
1563
1564 device_unregister(&virtpci_rootbus_device);
1565 bus_unregister(&virtpci_bus_type);
1566 debugfs_remove_recursive(virtpci_debugfs_dir);
1567 LOGINF("Leaving\n");
1568
1569 }
1570
1571 module_init(virtpci_mod_init);
1572 module_exit(virtpci_mod_exit);
1573 MODULE_LICENSE("GPL");
1574 MODULE_AUTHOR("Usha Srinivasan");
1575 MODULE_ALIAS("uisvirtpci");
1576
(deprecated) Btrfs devel tree