git.osdn.net Git - android-x86/external-libdrm.git/blob

1 /*

6 *

7 * Permission is hereby granted, free of charge, to any person obtaining a

8 * copy of this software and associated documentation files (the "Software"),

9 * to deal in the Software without restriction, including without limitation

10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

11 * and/or sell copies of the Software, and to permit persons to whom the

12 * Software is furnished to do so, subject to the following conditions:

13 *

14 * The above copyright notice and this permission notice (including the next

15 * paragraph) shall be included in all copies or substantial portions of the

16 * Software.

17 *

18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

21 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR

22 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

23 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

24 * DEALINGS IN THE SOFTWARE.

25 */

26 /*

27 * Authors:

28 * Jerome Glisse <glisse@freedesktop.org>

29 */

30 #include "drm_pciids.h"

31 #include "radeon_ms.h"

32 #include "amd_legacy_fence.h"

33

34

35 static uint32_t radeon_ms_mem_prios[] = {

36 DRM_BO_MEM_VRAM,

37 DRM_BO_MEM_TT,

38 DRM_BO_MEM_LOCAL,

39 };

40

41 static uint32_t radeon_ms_busy_prios[] = {

42 DRM_BO_MEM_TT,

43 DRM_BO_MEM_VRAM,

44 DRM_BO_MEM_LOCAL,

45 };

46

47 struct drm_bo_driver radeon_ms_bo_driver = {

48 .mem_type_prio = radeon_ms_mem_prios,

49 .mem_busy_prio = radeon_ms_busy_prios,

50 .num_mem_type_prio = sizeof(radeon_ms_mem_prios)/sizeof(uint32_t),

51 .num_mem_busy_prio = sizeof(radeon_ms_busy_prios)/sizeof(uint32_t),

52 .create_ttm_backend_entry = radeon_ms_create_ttm_backend,

53 .fence_type = r3xx_fence_types,

54 .invalidate_caches = radeon_ms_invalidate_caches,

55 .init_mem_type = radeon_ms_init_mem_type,

56 .evict_flags = radeon_ms_evict_flags,

57 .move = radeon_ms_bo_move,

58 .ttm_cache_flush = radeon_ms_ttm_flush,

59 };

60

61 struct drm_ioctl_desc radeon_ms_ioctls[] = {

62 DRM_IOCTL_DEF(DRM_AMD_CMD, amd_ioctl_cmd, DRM_AUTH),

63 DRM_IOCTL_DEF(DRM_AMD_RESETCP, radeon_ms_resetcp, DRM_AUTH),

64 };

65 int radeon_ms_num_ioctls = DRM_ARRAY_SIZE(radeon_ms_ioctls);

66

67 int radeon_ms_driver_dma_ioctl(struct drm_device *dev, void *data,

68 struct drm_file *file_priv)

69 {

70 struct drm_device_dma *dma = dev->dma;

71 struct drm_dma *d = data;

72

73 LOCK_TEST_WITH_RETURN(dev, file_priv);

74

75 /* Please don't send us buffers.

76 */

77 if (d->send_count != 0) {

78 DRM_ERROR("Process %d trying to send %d buffers via drmDMA\n",

79 DRM_CURRENTPID, d->send_count);

80 return -EINVAL;

81 }

82

83 /* Don't ask us buffer neither :)

84 */

85 DRM_ERROR("Process %d trying to get %d buffers (of %d max)\n",

86 DRM_CURRENTPID, d->request_count, dma->buf_count);

87 return -EINVAL;

88 }

89

90 void radeon_ms_driver_lastclose(struct drm_device * dev)

91 {

92 }

93

94 int radeon_ms_driver_load(struct drm_device *dev, unsigned long flags)

95 {

96 struct drm_radeon_private *dev_priv;

97 int ret = 0;

98

99 DRM_INFO("[radeon_ms] loading\n");

100 /* allocate and clear device private structure */

101 dev_priv = drm_alloc(sizeof(struct drm_radeon_private), DRM_MEM_DRIVER);

102 if (dev_priv == NULL)

103 return -ENOMEM;

104 memset(dev_priv, 0, sizeof(struct drm_radeon_private));

105 dev->dev_private = (void *)dev_priv;

106

107 /* initialize modesetting structure (must be done here) */

108 drm_mode_config_init(dev);

109

110 /* flags correspond to chipset family */

111 dev_priv->usec_timeout = 100;

112 dev_priv->family = flags & 0xffffU;

113 dev_priv->bus_type = flags & 0xff0000U;

114 /* initialize family functions */

115 ret = radeon_ms_family_init(dev);

116 if (ret != 0) {

117 radeon_ms_driver_unload(dev);

118 return ret;

119 }

120

121 dev_priv->fence = drm_alloc(sizeof(struct legacy_fence), DRM_MEM_DRIVER);

122 if (dev_priv->fence == NULL) {

123 radeon_ms_driver_unload(dev);

124 return -ENOMEM;

125 }

126 memset(dev_priv->fence, 0, sizeof(struct legacy_fence));

127

128 /* we don't want userspace to be able to map this so don't use

129 * drm_addmap */

130 dev_priv->mmio.offset = drm_get_resource_start(dev, 2);

131 dev_priv->mmio.size = drm_get_resource_len(dev, 2);

132 dev_priv->mmio.type = _DRM_REGISTERS;

133 dev_priv->mmio.flags = _DRM_RESTRICTED;

134 drm_core_ioremap(&dev_priv->mmio, dev);

135 /* map vram FIXME: IGP likely don't have any of this */

136 dev_priv->vram.offset = drm_get_resource_start(dev, 0);

137 dev_priv->vram.size = drm_get_resource_len(dev, 0);

138 dev_priv->vram.type = _DRM_FRAME_BUFFER;

139 dev_priv->vram.flags = _DRM_RESTRICTED;

140 drm_core_ioremap(&dev_priv->vram, dev);

141

142 /* save radeon initial state which will be restored upon module

143 * exit */

144 radeon_ms_state_save(dev, &dev_priv->load_state);

145 dev_priv->restore_state = 1;

146 memcpy(&dev_priv->driver_state, &dev_priv->load_state,

147 sizeof(struct radeon_state));

148

149 /* initialize irq */

150 ret = radeon_ms_irq_init(dev);

151 if (ret != 0) {

152 radeon_ms_driver_unload(dev);

153 return ret;

154 }

155

156 /* init bo driver */

157 dev_priv->fence_id_last = 1;

158 dev_priv->fence_reg = SCRATCH_REG2;

159 ret = drm_bo_driver_init(dev);

160 if (ret != 0) {

161 DRM_INFO("[radeon_ms] failed to init bo driver %d.\n", ret);

162 radeon_ms_driver_unload(dev);

163 return ret;

164 }

165 DRM_INFO("[radeon_ms] bo driver succesfull %d.\n", dev->bm.initialized);

166 /* initialize vram */

167 ret = drm_bo_init_mm(dev, DRM_BO_MEM_VRAM, 0, dev_priv->vram.size, 1);

168 if (ret != 0) {

169 radeon_ms_driver_unload(dev);

170 return ret;

171 }

172

173 /* initialize gpu address space (only after) VRAM initialization */

174 ret = radeon_ms_gpu_initialize(dev);

175 if (ret != 0) {

176 radeon_ms_driver_unload(dev);

177 return ret;

178 }

179 radeon_ms_gpu_restore(dev, &dev_priv->driver_state);

180

181 /* initialize ttm */

182 ret = drm_bo_init_mm(dev, DRM_BO_MEM_TT, 0,

183 dev_priv->gpu_gart_size / RADEON_PAGE_SIZE, 1);

184 if (ret != 0) {

185 radeon_ms_driver_unload(dev);

186 return ret;

187 }

188

189 /* initialize ring buffer */

190 /* set ring size to 4Mo FIXME: should make a parameter for this */

191 dev_priv->write_back_area_size = 4 * 1024;

192 dev_priv->ring_buffer_size = 4 * 1024 * 1024;

193 ret = radeon_ms_cp_init(dev);

194 if (ret != 0) {

195 radeon_ms_driver_unload(dev);

196 return ret;

197 }

198

199 /* initialize modesetting */

200 dev->mode_config.min_width = 0;

201 dev->mode_config.min_height = 0;

202 dev->mode_config.max_width = 4096;

203 dev->mode_config.max_height = 4096;

204 dev->mode_config.fb_base = dev_priv->vram.offset;

205 ret = radeon_ms_crtc_create(dev, 1);

206 if (ret != 0) {

207 radeon_ms_driver_unload(dev);

208 return ret;

209 }

210 ret = radeon_ms_outputs_from_rom(dev);

211 if (ret < 0) {

212 radeon_ms_driver_unload(dev);

213 return ret;

214 } else if (!ret) {

215 ret = radeon_ms_outputs_from_properties(dev);

216 if (ret < 0) {

217 radeon_ms_driver_unload(dev);

218 return ret;

219 } else if (ret == 0) {

220 DRM_INFO("[radeon_ms] no outputs !\n");

221 }

222 } else {

223 DRM_INFO("[radeon_ms] added %d outputs from rom.\n", ret);

224 }

225 ret = radeon_ms_connectors_from_rom(dev);

226 if (ret < 0) {

227 radeon_ms_driver_unload(dev);

228 return ret;

229 } else if (!ret) {

230 ret = radeon_ms_connectors_from_properties(dev);

231 if (ret < 0) {

232 radeon_ms_driver_unload(dev);

233 return ret;

234 } else if (!ret) {

235 DRM_INFO("[radeon_ms] no connectors !\n");

236 }

237 } else {

238 DRM_INFO("[radeon_ms] added %d connectors from rom.\n", ret);

239 }

240 radeon_ms_outputs_save(dev, &dev_priv->load_state);

241 drm_initial_config(dev, false);

242

243 ret = drm_irq_install(dev);

244 if (ret != 0) {

245 radeon_ms_driver_unload(dev);

246 return ret;

247 }

248

249 /* initialze driver specific */

250 ret = amd_legacy_cmd_module_initialize(dev);

251 if (ret != 0) {

252 radeon_ms_driver_unload(dev);

253 return ret;

254 }

255

256 if (dev->primary && dev->control) {

257 DRM_INFO("[radeon_ms] control 0x%lx, render 0x%lx\n",

258 (long)dev->primary->device, (long)dev->control->device);

259 } else {

260 DRM_INFO("[radeon_ms] error control 0x%lx, render 0x%lx\n",

261 (long)dev->primary, (long)dev->control);

262 }

263 DRM_INFO("[radeon_ms] successfull initialization\n");

264 return 0;

265 }

266

267 int radeon_ms_driver_open(struct drm_device * dev, struct drm_file *file_priv)

268 {

269 return 0;

270 }

271

272

273 int radeon_ms_driver_unload(struct drm_device *dev)

274 {

275 struct drm_radeon_private *dev_priv = dev->dev_private;

276

277 if (dev_priv == NULL) {

278 return 0;

279 }

280

281 /* cleanup modesetting */

282 drm_mode_config_cleanup(dev);

283 DRM_INFO("[radeon_ms] modesetting clean\n");

284 radeon_ms_outputs_restore(dev, &dev_priv->load_state);

285 radeon_ms_connectors_destroy(dev);

286 radeon_ms_outputs_destroy(dev);

287

288 /* shutdown specific driver */

289 amd_legacy_cmd_module_destroy(dev);

290

291 /* shutdown cp engine */

292 radeon_ms_cp_finish(dev);

293 DRM_INFO("[radeon_ms] cp clean\n");

294

295 drm_irq_uninstall(dev);

296 DRM_INFO("[radeon_ms] irq uninstalled\n");

297

298 DRM_INFO("[radeon_ms] unloading\n");

299 /* clean ttm memory manager */

300 mutex_lock(&dev->struct_mutex);

301 if (drm_bo_clean_mm(dev, DRM_BO_MEM_TT, 1)) {

302 DRM_ERROR("TT memory manager not clean. Delaying takedown\n");

303 }

304 mutex_unlock(&dev->struct_mutex);

305 DRM_INFO("[radeon_ms] TT memory clean\n");

306 /* finish */

307 if (dev_priv->bus_finish) {

308 dev_priv->bus_finish(dev);

309 }

310 DRM_INFO("[radeon_ms] bus down\n");

311 /* clean vram memory manager */

312 mutex_lock(&dev->struct_mutex);

313 if (drm_bo_clean_mm(dev, DRM_BO_MEM_VRAM, 1)) {

314 DRM_ERROR("VRAM memory manager not clean. Delaying takedown\n");

315 }

316 mutex_unlock(&dev->struct_mutex);

317 DRM_INFO("[radeon_ms] VRAM memory clean\n");

318 /* clean memory manager */

319 drm_bo_driver_finish(dev);

320 DRM_INFO("[radeon_ms] memory manager clean\n");

321 /* restore card state */

322 if (dev_priv->restore_state) {

323 radeon_ms_state_restore(dev, &dev_priv->load_state);

324 }

325 DRM_INFO("[radeon_ms] state restored\n");

326 if (dev_priv->mmio.handle) {

327 drm_core_ioremapfree(&dev_priv->mmio, dev);

328 }

329 if (dev_priv->vram.handle) {

330 drm_core_ioremapfree(&dev_priv->vram, dev);

331 }

332 DRM_INFO("[radeon_ms] map released\n");

333 drm_free(dev_priv->fence, sizeof(struct legacy_fence), DRM_MEM_DRIVER);

334 drm_free(dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER);

335 dev->dev_private = NULL;

336

337

338 DRM_INFO("[radeon_ms] that's all the folks\n");

339 return 0;

340 }

341