Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ieee1394...
[linux-2.6] / drivers / s390 / scsi / zfcp_ccw.c
1 /*
2  * This file is part of the zfcp device driver for
3  * FCP adapters for IBM System z9 and zSeries.
4  *
5  * (C) Copyright IBM Corp. 2002, 2006
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2, or (at your option)
10  * any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21
22 #include "zfcp_ext.h"
23
24 #define ZFCP_LOG_AREA                   ZFCP_LOG_AREA_CONFIG
25
26 static int zfcp_ccw_probe(struct ccw_device *);
27 static void zfcp_ccw_remove(struct ccw_device *);
28 static int zfcp_ccw_set_online(struct ccw_device *);
29 static int zfcp_ccw_set_offline(struct ccw_device *);
30 static int zfcp_ccw_notify(struct ccw_device *, int);
31 static void zfcp_ccw_shutdown(struct ccw_device *);
32
33 static struct ccw_device_id zfcp_ccw_device_id[] = {
34         {CCW_DEVICE_DEVTYPE(ZFCP_CONTROL_UNIT_TYPE,
35                             ZFCP_CONTROL_UNIT_MODEL,
36                             ZFCP_DEVICE_TYPE,
37                             ZFCP_DEVICE_MODEL)},
38         {CCW_DEVICE_DEVTYPE(ZFCP_CONTROL_UNIT_TYPE,
39                             ZFCP_CONTROL_UNIT_MODEL,
40                             ZFCP_DEVICE_TYPE,
41                             ZFCP_DEVICE_MODEL_PRIV)},
42         {},
43 };
44
45 static struct ccw_driver zfcp_ccw_driver = {
46         .owner       = THIS_MODULE,
47         .name        = ZFCP_NAME,
48         .ids         = zfcp_ccw_device_id,
49         .probe       = zfcp_ccw_probe,
50         .remove      = zfcp_ccw_remove,
51         .set_online  = zfcp_ccw_set_online,
52         .set_offline = zfcp_ccw_set_offline,
53         .notify      = zfcp_ccw_notify,
54         .shutdown    = zfcp_ccw_shutdown,
55         .driver = {
56                 .groups = zfcp_driver_attr_groups,
57         },
58 };
59
60 MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id);
61
62 /**
63  * zfcp_ccw_probe - probe function of zfcp driver
64  * @ccw_device: pointer to belonging ccw device
65  *
66  * This function gets called by the common i/o layer and sets up the initial
67  * data structures for each fcp adapter, which was detected by the system.
68  * Also the sysfs files for this adapter will be created by this function.
69  * In addition the nameserver port will be added to the ports of the adapter
70  * and its sysfs representation will be created too.
71  */
72 static int
73 zfcp_ccw_probe(struct ccw_device *ccw_device)
74 {
75         struct zfcp_adapter *adapter;
76         int retval = 0;
77
78         down(&zfcp_data.config_sema);
79         adapter = zfcp_adapter_enqueue(ccw_device);
80         if (!adapter)
81                 retval = -EINVAL;
82         else
83                 ZFCP_LOG_DEBUG("Probed adapter %s\n",
84                                zfcp_get_busid_by_adapter(adapter));
85         up(&zfcp_data.config_sema);
86         return retval;
87 }
88
89 /**
90  * zfcp_ccw_remove - remove function of zfcp driver
91  * @ccw_device: pointer to belonging ccw device
92  *
93  * This function gets called by the common i/o layer and removes an adapter
94  * from the system. Task of this function is to get rid of all units and
95  * ports that belong to this adapter. And in addition all resources of this
96  * adapter will be freed too.
97  */
98 static void
99 zfcp_ccw_remove(struct ccw_device *ccw_device)
100 {
101         struct zfcp_adapter *adapter;
102         struct zfcp_port *port, *p;
103         struct zfcp_unit *unit, *u;
104
105         ccw_device_set_offline(ccw_device);
106         down(&zfcp_data.config_sema);
107         adapter = dev_get_drvdata(&ccw_device->dev);
108
109         ZFCP_LOG_DEBUG("Removing adapter %s\n",
110                        zfcp_get_busid_by_adapter(adapter));
111         write_lock_irq(&zfcp_data.config_lock);
112         list_for_each_entry_safe(port, p, &adapter->port_list_head, list) {
113                 list_for_each_entry_safe(unit, u, &port->unit_list_head, list) {
114                         list_move(&unit->list, &port->unit_remove_lh);
115                         atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE,
116                                         &unit->status);
117                 }
118                 list_move(&port->list, &adapter->port_remove_lh);
119                 atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
120         }
121         atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
122         write_unlock_irq(&zfcp_data.config_lock);
123
124         list_for_each_entry_safe(port, p, &adapter->port_remove_lh, list) {
125                 list_for_each_entry_safe(unit, u, &port->unit_remove_lh, list) {
126                         if (atomic_test_mask(ZFCP_STATUS_UNIT_REGISTERED,
127                                 &unit->status))
128                                 scsi_remove_device(unit->device);
129                         zfcp_unit_dequeue(unit);
130                 }
131                 zfcp_port_dequeue(port);
132         }
133         zfcp_adapter_wait(adapter);
134         zfcp_adapter_dequeue(adapter);
135
136         up(&zfcp_data.config_sema);
137 }
138
139 /**
140  * zfcp_ccw_set_online - set_online function of zfcp driver
141  * @ccw_device: pointer to belonging ccw device
142  *
143  * This function gets called by the common i/o layer and sets an adapter
144  * into state online. Setting an fcp device online means that it will be
145  * registered with the SCSI stack, that the QDIO queues will be set up
146  * and that the adapter will be opened (asynchronously).
147  */
148 static int
149 zfcp_ccw_set_online(struct ccw_device *ccw_device)
150 {
151         struct zfcp_adapter *adapter;
152         int retval;
153
154         down(&zfcp_data.config_sema);
155         adapter = dev_get_drvdata(&ccw_device->dev);
156
157         retval = zfcp_erp_thread_setup(adapter);
158         if (retval) {
159                 ZFCP_LOG_INFO("error: start of error recovery thread for "
160                               "adapter %s failed\n",
161                               zfcp_get_busid_by_adapter(adapter));
162                 goto out;
163         }
164
165         retval = zfcp_adapter_scsi_register(adapter);
166         if (retval)
167                 goto out_scsi_register;
168
169         /* initialize request counter */
170         BUG_ON(!zfcp_reqlist_isempty(adapter));
171         adapter->req_no = 0;
172
173         zfcp_erp_modify_adapter_status(adapter, 10, NULL,
174                                        ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
175         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 85,
176                                 NULL);
177         zfcp_erp_wait(adapter);
178         goto out;
179
180  out_scsi_register:
181         zfcp_erp_thread_kill(adapter);
182  out:
183         up(&zfcp_data.config_sema);
184         return retval;
185 }
186
187 /**
188  * zfcp_ccw_set_offline - set_offline function of zfcp driver
189  * @ccw_device: pointer to belonging ccw device
190  *
191  * This function gets called by the common i/o layer and sets an adapter
192  * into state offline.
193  */
194 static int
195 zfcp_ccw_set_offline(struct ccw_device *ccw_device)
196 {
197         struct zfcp_adapter *adapter;
198
199         down(&zfcp_data.config_sema);
200         adapter = dev_get_drvdata(&ccw_device->dev);
201         zfcp_erp_adapter_shutdown(adapter, 0, 86, NULL);
202         zfcp_erp_wait(adapter);
203         zfcp_erp_thread_kill(adapter);
204         up(&zfcp_data.config_sema);
205         return 0;
206 }
207
208 /**
209  * zfcp_ccw_notify
210  * @ccw_device: pointer to belonging ccw device
211  * @event: indicates if adapter was detached or attached
212  *
213  * This function gets called by the common i/o layer if an adapter has gone
214  * or reappeared.
215  */
216 static int
217 zfcp_ccw_notify(struct ccw_device *ccw_device, int event)
218 {
219         struct zfcp_adapter *adapter;
220
221         down(&zfcp_data.config_sema);
222         adapter = dev_get_drvdata(&ccw_device->dev);
223         switch (event) {
224         case CIO_GONE:
225                 ZFCP_LOG_NORMAL("adapter %s: device gone\n",
226                                 zfcp_get_busid_by_adapter(adapter));
227                 zfcp_erp_adapter_shutdown(adapter, 0, 87, NULL);
228                 break;
229         case CIO_NO_PATH:
230                 ZFCP_LOG_NORMAL("adapter %s: no path\n",
231                                 zfcp_get_busid_by_adapter(adapter));
232                 zfcp_erp_adapter_shutdown(adapter, 0, 88, NULL);
233                 break;
234         case CIO_OPER:
235                 ZFCP_LOG_NORMAL("adapter %s: operational again\n",
236                                 zfcp_get_busid_by_adapter(adapter));
237                 zfcp_erp_modify_adapter_status(adapter, 11, NULL,
238                                                ZFCP_STATUS_COMMON_RUNNING,
239                                                ZFCP_SET);
240                 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
241                                         89, NULL);
242                 break;
243         }
244         zfcp_erp_wait(adapter);
245         up(&zfcp_data.config_sema);
246         return 1;
247 }
248
249 /**
250  * zfcp_ccw_register - ccw register function
251  *
252  * Registers the driver at the common i/o layer. This function will be called
253  * at module load time/system start.
254  */
255 int __init
256 zfcp_ccw_register(void)
257 {
258         return ccw_driver_register(&zfcp_ccw_driver);
259 }
260
261 /**
262  * zfcp_ccw_shutdown - gets called on reboot/shutdown
263  *
264  * Makes sure that QDIO queues are down when the system gets stopped.
265  */
266 static void
267 zfcp_ccw_shutdown(struct ccw_device *cdev)
268 {
269         struct zfcp_adapter *adapter;
270
271         down(&zfcp_data.config_sema);
272         adapter = dev_get_drvdata(&cdev->dev);
273         zfcp_erp_adapter_shutdown(adapter, 0, 90, NULL);
274         zfcp_erp_wait(adapter);
275         up(&zfcp_data.config_sema);
276 }
277
278 #undef ZFCP_LOG_AREA